     }
 
     func registerWord(name: String, words threadedCode:String[]) {
-        createName(name)
-        heap += Cell.Branch(destinationIndex: heap.endIndex + 1)
+        self.createName(name)
+        self.heap += Cell.Branch(destinationIndex: self.heap.endIndex + 1)
         for name in threadedCode {
-            heap += cellForName(name)
+            self.heap += self.cellForName(name)
         }
     }
 
     func registerConstant(name: String, value: Int) {
-        createName(name)
-        heap += Cell.Constant(value: value)
+        self.createName(name)
+        self.heap += Cell.Constant(value: value)
     }
 
     func registerVariable(name: String, initialValue: Int) {
-        let address = createName(name)
-        heap += Cell.Variable(address: address)
+        let address = self.createName(name)
+        self.heap += Cell.Variable(address: address)
     }
 
     func executeWord(word: String) -> Bool {

        self.next()
    }

    func printTopOfStackPrim() {
        print("\(self.pop()) ")
        self.next()
    }

    func fetchPrim() {
        let indexLiteral = self.pop()
        switch indexLiteral {
        case let .Literal(index):

        self.registerPrimitives()
    }

    func registerPrimitive(name:String, execute primitiveClosure: ()->Void) -> Int {
        let index = self.primitiveTable.endIndex
        self.primitiveDictionary[name] = index
        self.primitiveTable += primitiveClosure
        return index
    }

    func next() {   // inner interpreter
        var currentItem = self.heap[self.instructionPointer++]

        switch currentItem {
        case let .Thread(index):
            self.returnStack += Cell.Thread(index: instructionPointer)
            self.instructionPointer = index

        case let .Primitive(num):
            self.primitiveTable[num]()

        case let .Branch(destinationIndex):
            self.instructionPointer = destinationIndex

        case let .ZeroBranch(destinationIndex):
            switch self.pop() {
            case let .Literal(value):
                if (value == 0) {
                    self.instructionPointer = destinationIndex
                }
            default:
                self.error()
