anchor.diff:      response.OutputStream.Close();
   
   // Calculates the absolute distance between two GUIDs
  -let distance (a: GUID) (b: GUID) : U128 =
  -    let (a1, a2) = a
  -    let (b1, b2) = b // below: Unsigned shenanigans
  -    let n1 = if a1 > b1 then a1 - b1 else b1 - a1
  -    let n2 = if a2 > b2 then a2 - b2 else b2 - a2
  -    (n1, n2)
  +let distance (one: GUID) (two: GUID) : U128 =
  +    // Unsigned shenanigans
  +    let a = if one.a > two.a then one.a - two.a else two.a - one.a
  +    let b = if one.b > two.b then one.b - two.b else two.b - one.b
  +    {a = a; b = b}
  +
  +// Converts a GUID to a string
  +let serialize_guid (guid: GUID) : string = sprintf "%020d%020d" guid.a guid.b
  +
  +// Attempts to convert the given string to a GUID
  +let deserialize_guid (str: string) : GUID option =
  +    if not (str.Length = 40) then
  +        None
  +    else
  +        let a = str.[..19]
  +        let b = str.[20..]
  +        try
  +            let ua = System.Convert.ToUInt64(a)
  +            let ub = System.Convert.ToUInt64(b)
  +            Some({a = ua; b = ub}) //
  +        with
  +            | ex -> None
   
   // Serializes the state of the given node
  -let serialize (node: Node) : string = JsonConvert.SerializeObject node
  +let serialize (node: Node) : string =
  +    let serialize_guid_map m =
  +        Map.foldBack (fun k v acc -> Map.add (serialize_guid k) v acc) m Map.empty
  +    let leaves = serialize_guid_map node.leaves
  +    let neighbors = serialize_guid_map node.neighbors
  +    let minleaf = serialize_guid node.minleaf
  +    let maxleaf = serialize_guid node.maxleaf
  +    let guid = serialize_guid node.guid
  +    let routing_table = List.map serialize_guid_map node.routing_table
  +    let new_node: SerializableNode =
  +        {
  +            guid = guid;
  +            address = node.address;
  +            neighbors = neighbors;
  +            leaves = leaves;
  +            minleaf = minleaf;
  +            maxleaf = maxleaf;
  +            routing_table = routing_table;
  +        }
  +    JsonConvert.SerializeObject new_node
   
   // Deserializes the state of the given node
  -let deserialize (json: string) : Node = JsonConvert.DeserializeObject<Node> json
  +let deserialize (json: string) : Node =
  +    let node = JsonConvert.DeserializeObject<SerializableNode> json
  +    let deserialize_safe_guid guid =
  +        match deserialize_guid guid with
  +        | Some(g) -> g
  +        | None -> failwith (sprintf "Attempted to deserialize invalid GUID: %s" guid)
  +    let deserialize_guid_map m =
  +        Map.foldBack (fun k v acc -> Map.add (deserialize_safe_guid k) v acc) m Map.empty
  +    let leaves = deserialize_guid_map node.leaves
  +    let neighbors = deserialize_guid_map node.neighbors
  +    let minleaf = deserialize_safe_guid node.minleaf
  +    let maxleaf = deserialize_safe_guid node.maxleaf
  +    let guid = deserialize_safe_guid node.guid
  +    let routing_table = List.map deserialize_guid_map node.routing_table
  +    let new_node: Node =
  +        {
  +            guid = guid;
  +            address = node.address;
  +            neighbors = neighbors;
  +            leaves = leaves;
  +            minleaf = minleaf;
  +            maxleaf = maxleaf;
  +            routing_table = routing_table;
  +        }
  +    new_node
   
   // Convert a byte array to an u64. Please don't use an array that is more than
   // 8 bytes long... (tip: You get undefined behavior)
  
positive.code: // 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
  
negative.code:     let a = to_u64 bytes.[..7]
      let b = to_u64 bytes.[8..15]
      //printfn "Hash : a / b : %d / %d" a b
      {a = a; b = b}
  
  // Makes the given pastry node start listening...
  let start_listening (node: Node) =
  