         self.push(self.returnStack[self.returnStack.endIndex - 1])
     }
 
-    func exitPrim() {
+    func exitPrimitive() {
         switch self.rpop() {
         case let .Thread(index):
-            instructionPointer = index
+            self.instructionPointer = index
         default:
             self.error()
         }
-        next()
-    }
-
-    func dotsPrim() {
+        self.next()
+    }
+
+    func dotsPrimitive() {
         for i in self.dataStack {
             print("\(i) ")
         }
         self.next()
     }
 
-    func dupPrim() {
+    func dupPrimitive() {
         self.dup()
         self.next()
     }
 
-    func dropPrim() {
+    func dropPrimitive() {
         self.pop()
         self.next()
     }
 
-    func swapPrim() {
+    func swapPrimitive() {
         self.swap()
         self.next()
     }
 
-    func overPrim() {
+    func overPrimitive() {
         self.over()
         self.next()
     }
 
-    func rotPrim() {
+    func rotPrimitive() {
         self.rot()
         self.next()
     }
 
-    func negrotPrim() {
+    func negrotPrimitive() {
         self.negrot()
         self.next()
     }
 
-    func nipPrim() {
+    func nipPrimitive() {
         self.nip()
         self.next()
     }
 
-    func tuckPrim() {
+    func tuckPrimitive() {
         self.tuck()
         self.next()
     }
 
-    func intMathPrimAux(action:(Int, Int)->Int) {
-        let b = self.pop()
-        let a = self.pop()
-        switch a {
-        case let .Literal(aValue):
-            switch b {
-            case let .Literal(bValue):
-                self.push(Cell.Literal(value:action(aValue, bValue)))
+    func integerMathOperation(action:(lhs:Int, rhs:Int)->Int) {
+        let bCell = self.pop()
+        let aCell = self.pop()
+        switch aCell {
+        case let .Literal(a):
+            switch bCell {
+            case let .Literal(b):
+                self.push(Cell.Literal(value:action(lhs:a, rhs:b)))
             default:
                 self.error()
             }

        }
    }

    func addPrim() {
        intMathPrimAux { $0 + $1 }
        self.next()
    }

    func subPrim() {
        intMathPrimAux { $0 - $1 }
        self.next()
    }

    func multPrim() {
        intMathPrimAux { $0 * $1 }
        self.next()
    }

    func divPrim() {
        intMathPrimAux { $0 / $1 }
        self.next()
    }

    func multDivPrim() {
        let c = self.pop()
        intMathPrimAux { $0 * $1 }
        self.push(c)
        intMathPrimAux { $0 / $1 }
        self.next()
    }

    func andPrim() {
        intMathPrimAux { $0 & $1 }
        self.next()
    }

    func orPrim() {
        intMathPrimAux { $0 | $1 }
        self.next()
    }

    func xorPrim() {
        intMathPrimAux { $0 ^ $1 }
        self.next()
    }

    func greaterThanZeroPrim() {
        switch self.pop() {
        case let .Literal(value):
            if value > 0 {

        self.next()
    }

    func toRPrimitive() {
        self.toR()
        self.next()
    }

    func fromRPrimitive() {
        self.fromR()
        self.next()
    }

    func fetchRPrimitive() {
        self.fetchR()
        self.next()
    }

    func wordsPrimitive() {
        for (k, v) in self.primitiveDictionary {
            print("\(k) ")
        }
