diff --git a/client2.gpsl b/client2.gpsl
index 8cc3c60..596b26b 100644
--- a/client2.gpsl
+++ b/client2.gpsl
@@ -9,7 +9,8 @@ fn main() {
     println("d: " + d)
     let e = encrypt(24)
     println("e: " + e)
-    let r = a + b + c + d + e
+    let f = encrypt(15)
+    let r = a + b + c + d + e - f
     println("r: " + decrypt(r));
-    println(decrypt(r) - 15)
+    println(decrypt(r * 2))
 }
diff --git a/src/elliptic_curve/encryption.rs b/src/elliptic_curve/encryption.rs
index 80caacd..9df1bcc 100644
--- a/src/elliptic_curve/encryption.rs
+++ b/src/elliptic_curve/encryption.rs
@@ -1,6 +1,6 @@
 use std::{
     fmt::Display,
-    ops::{Add, Sub},
+    ops::{Add, Mul, Sub},
     sync::mpsc,
     thread,
 };
@@ -70,6 +70,29 @@ impl Sub for EncryptedEllipticCurvePoint {
     }
 }
 
+impl Mul<U512> for EncryptedEllipticCurvePoint {
+    type Output = Self;
+
+    fn mul(self, rhs: U512) -> Self::Output {
+        let mut tmp = self;
+        let mut point: Option<EncryptedEllipticCurvePoint> = None;
+        let mut n = rhs;
+        while n > U512::zero() {
+            if n & U512::one() == U512::one() {
+                if let Some(s_point) = point {
+                    point = Some(s_point + tmp);
+                } else {
+                    point = Some(tmp);
+                }
+            }
+
+            n = n >> 1;
+            tmp = tmp + tmp;
+        }
+        point.unwrap()
+    }
+}
+
 impl Encryption {
     pub fn ec_point_to_plain(&self, point: EllipticCurvePoint) -> U512 {
         match point {
diff --git a/src/gpsl/vm/gpsl.rs b/src/gpsl/vm/gpsl.rs
index 701d34b..654492a 100644
--- a/src/gpsl/vm/gpsl.rs
+++ b/src/gpsl/vm/gpsl.rs
@@ -423,21 +423,48 @@ impl GPSL {
                                 },
                                 Err(err) => Err(err),
                             },
-                            NodeKind::MUL => match GPSL::extract_number(lhs) {
+                            NodeKind::MUL => match lhs.clone() {
+                                Variable::Number { value: lhs } => match rhs {
+                                    Variable::Number { value: rhs } => {
+                                        Ok(Some(Variable::Number { value: lhs * rhs }))
+                                    }
+                                    _ => Err("Cannot multiply non-number to number.".to_string()),
+                                },
+                                Variable::PureEncrypted { value: lhs } => match rhs {
+                                    Variable::Number { value: rhs } => {
+                                        Ok(Some(Variable::PureEncrypted {
+                                            value: lhs * U512::from(rhs),
+                                        }))
+                                    }
+                                    Variable::U512 { value: rhs } => {
+                                        Ok(Some(Variable::PureEncrypted { value: lhs * rhs }))
+                                    }
+                                    _ => Err("Cannot multiply non-number to ppe.".to_string()),
+                                },
+                                _ => Err("Cannot multiply non-number.".to_string()),
+                            },
+                            /*match GPSL::extract_number(lhs) {
                                 Ok(lhs) => match GPSL::extract_number(rhs) {
                                     Ok(rhs) => Ok(Some(Variable::Number { value: lhs * rhs })),
                                     Err(err) => Err(err),
                                 },
                                 Err(err) => Err(err),
-                            },
-                            NodeKind::SUB => match GPSL::extract_number(lhs) {
-                                Ok(lhs) => match GPSL::extract_number(rhs) {
-                                    Ok(rhs) => Ok(Some(Variable::Number { value: lhs - rhs })),
-                                    Err(err) => Err(err),
+                            },*/
+                            NodeKind::SUB => match lhs.clone() {
+                                Variable::Number { value: lhs } => match rhs {
+                                    Variable::Number { value: rhs } => {
+                                        Ok(Some(Variable::Number { value: lhs - rhs }))
+                                    }
+                                    _ => Err("Cannot subtract non-number from number.".to_string()),
                                 },
-                                Err(err) => Err(err),
+                                Variable::PureEncrypted { value: lhs } => match rhs {
+                                    Variable::PureEncrypted { value: rhs } => {
+                                        Ok(Some(Variable::PureEncrypted { value: lhs - rhs }))
+                                    }
+                                    _ => Err("Cannot subtract non-ppe from ppe.".to_string()),
+                                },
+                                _ => Err("Cannot subtract non-number.".to_string()),
                             },
-
                             NodeKind::EQ => {
                                 if lhs == rhs {
                                     Ok(Some(Variable::Number { value: 1 }))