anchor.diff:  // Get a list of the digits of a GUID as u64s
   // NOTE: (could be u16 with the default value of 'b' (DIGIT_POWER))
   let get_digits (guid: GUID) : uint64 list =
  -    let (a, b) = guid
       let get_bytes (x: uint64): byte[] =
           let barr =
               if BitConverter.IsLittleEndian then
  
positive.code: // Creates a local node and makes it join the Pastry network
  let join_network (address: NetworkLocation) (peer: NetworkLocation option) =
      let guid = hash address
      let (a, b) = guid
      printfn "? Pastry GUID: %020d%020d" a b
      let node = {
          guid = guid;
          address = address;
          leaves = Map.empty;
  
negative.code:         | _ -> failwith "This should not happen: The list have different sizes"
      inner (get_digits a) (get_digits b) 0
  
  // Adds the given node as a neighbor if it makes sense (I'm not using this ATM)
  let try_add_neighbor (node: Node) (guid: GUID) (address: NetworkLocation) : Node =
      if node.neighbors.Count < MAX_LEAVES then
          { node with neighbors = Map.add guid address node.neighbors; }
      else
          node
  
  // Tries to add the given guid/address pair to the node as a leaf
  let try_add_leaf (node: Node) (guid: GUID) (address: NetworkLocation) : Node =
      if node.leaves.Count < MAX_LEAVES then // Room for more
          let minleaf = if guid < node.minleaf then guid else node.minleaf
          let maxleaf = if guid > node.maxleaf then guid else node.maxleaf
          let leaves = Map.add guid address node.leaves
          { node with leaves = leaves; minleaf = minleaf; maxleaf = maxleaf; }
      else
          if guid > node.minleaf && guid < node.maxleaf then // Within replacement range
              if guid >= node.guid then
                  let leaves = Map.add guid address (Map.remove node.maxleaf node.leaves)
                  let maxleaf = Map.foldBack (fun k _ acc -> if k > acc then k else acc) leaves guid
                  { node with leaves = leaves; maxleaf = maxleaf; }
              else
                  let leaves = Map.add guid address (Map.remove node.minleaf node.leaves)
                  let minleaf = Map.foldBack (fun k _ acc -> if k < acc then k else acc) leaves guid
                  { node with leaves = leaves; minleaf = minleaf; }
          else
              node
  
  // Handles a message intended for this node
  let handle_message (node: Node) (typ: MessageType) (message: string) (key: GUID) =
      printfn "PASTRY: Handling '%A' message '%s'..." typ message
      match typ with
      | Join -> // A node is requesting to join, and this is the one with the nearest GUID
          let firstsep = message.IndexOf(SEPARATOR)
          let address = message.[..firstsep-1]
          let states = message.[firstsep + SEPARATOR.Length..]
          // Failure is unimportant here, no?
          ignore <| send_message address JoinState states key
          node
  
      | JoinState -> // This node receives the states needed to initialize itself
          let string_states = message.Split([|SEPARATOR|], StringSplitOptions.RemoveEmptyEntries)
          let states = Array.foldBack (fun str acc -> (deserialize str)::acc) string_states []
  
          let rec last = function
  