anchor.diff:          abstract Native: bool
           abstract Pointer: IdType
           abstract Print: unit
  -
  -    let fs_values = new Dictionary<IdType, Lump>()
  -    let mutable pointer_counter = 0
  -
  -    let nextPointerCounter () =
  -        pointer_counter <- pointer_counter + 1
  -    
  -    type 'a FSLump(value : 'a) as this =
  -        let current_count = new IdType(pointer_counter)
  -        do
  -            // pointer_counter <- pointer_counter + 1
  -            nextPointerCounter()
  -            fs_values.Add(current_count, this :> Lump)
  -    
  +    
  +    type FSValuesStorage () =
  +        let _dict = new Dictionary<IdType, Lump>()
  +        // only allow positive integers
  +        let mutable _pointer_counter = 0
  +        let nextPointerCounter () =
  +            _pointer_counter <- _pointer_counter + 1
  +                    
  +        member this.Dict = _dict
  +        member this.Insert (lump: FSLump<_>) =
  +            this.Dict.Add(IdType(_pointer_counter), lump)
  +            nextPointerCounter ()
  +            // _pointer_counter
  +        member this.CurrentPointer = _pointer_counter
  +        member this.Lookup pointer = this.Dict.[pointer]
  +
  +    
  +    and 'a FSLump(value : 'a, fscontext: FSValuesStorage) as this =
  +        let _fscontext = fscontext
  +        let _pointer = _fscontext.CurrentPointer
  +        do _fscontext.Insert(this)
           member this.Value = value
  +
           interface Lump with
               member this.Native = true
  -            member this.Pointer = current_count
  +            member this.Pointer = IdType(_pointer)
               member this.Print = printf "%A\n" this
       
  -
  +    let fscontext = new FSValuesStorage()
   
       type JSLump(pointer: nativeint) =
  -
           let mutable disposed = false
           let cleanup disposing =
               printf "cleanup!\n"
  -            // this.Print
               if not disposed then
                   disposed <- true
  -
                   if disposing then
                       printf "disposing is true!\n"
                   V8.disposeHandle(pointer)
  
positive.code:         // a FSLump
          let extract_fslump (arg: JSLump) =
              let index = IdType(V8.get_pointer_lump((arg :> Lump).Pointer))
              fs_values.[index]
  
          // process_arg takes an argument
          let process_arg (arg: JSLump) =
              let lumpy_arg = arg :> Lump
              if (V8.get_pointer_lump(lumpy_arg.Pointer)) = -1 then lumpy_arg
              else extract_fslump(arg)
      
          let evaluator context args =
              // the JSLumps that contain a pointer to a FSLump are processed into that FSLump
              let processed_args = args |> get_all_JS_arguments JSLump.Context |> Array.map process_arg
              printf "these are processed_args %A\n" (Array.toList processed_args)
              let result = eval_array (processed_args.[0]) (Array.toList (processed_args.[1..]))
              printf "this is the result %A\n" <| get_fslump_value(result)
              // return the pointer to a FLump object (in JavaScript)
  
negative.code: namespace JSEmbedding
  
  open System.Runtime.InteropServices
  open System
  