anchor.diff:  begin
     F.Ite.Free;
     F.val := nil;
  +end;
  +
  +function UuidFromString(p: PSOChar; Uuid: PGUID): Boolean;
  +const
  +  hex2bin: array[48..102] of Byte = (
  +     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
  +     0,10,11,12,13,14,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  +     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  +     0,10,11,12,13,14,15);
  +type
  +  TState = (stEatSpaces, stStart, stHEX, stBracket, stEnd);
  +  TUUID = record
  +    case byte of
  +      0: (guid: TGUID);
  +      1: (bytes: array[0..15] of Byte);
  +      2: (words: array[0..7] of Word);
  +      3: (ints: array[0..3] of Cardinal);
  +      4: (i64s: array[0..1] of UInt64);
  +  end;
  +
  +  function ishex(const c: SOChar): Boolean; {$IFDEF HAVE_INLINE} inline;{$ENDIF}
  +  begin
  +    result := (c < #256) and (AnsiChar(c) in ['0'..'9', 'a'..'z', 'A'..'Z'])
  +  end;
  +var
  +  pos: Byte;
  +  state, saved: TState;
  +  bracket, separator: Boolean;
  +label
  +  redo;
  +begin
  +  FillChar(Uuid^, SizeOf(TGUID), 0);
  +  saved := stStart;
  +  state := stEatSpaces;
  +  bracket := false;
  +  separator := false;
  +  pos := 0;
  +  while true do
  +redo:
  +  case state of
  +    stEatSpaces:
  +      begin
  +        while true do
  +          case p^ of
  +            ' ', #13, #10, #9: inc(p);
  +          else
  +            state := saved;
  +            goto redo;
  +          end;
  +      end;
  +    stStart:
  +      case p^ of
  +        '{':
  +          begin
  +            bracket := true;
  +            inc(p);
  +            state := stEatSpaces;
  +            saved := stHEX;
  +            pos := 0;
  +          end;
  +      else
  +        state := stHEX;
  +      end;
  +    stHEX:
  +      case pos of
  +        0..7:
  +          if ishex(p^) then
  +          begin
  +            Uuid^.D1 := (Uuid^.D1 * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        8:
  +          if (p^ = '-') then
  +          begin
  +            separator := true;
  +            inc(p);
  +            inc(pos)
  +          end else
  +            inc(pos);
  +        13,18,23:
  +           if separator then
  +           begin
  +             if p^ <> '-' then
  +             begin
  +               Result := False;
  +               Exit;
  +             end;
  +             inc(p);
  +             inc(pos);
  +           end else
  +             inc(pos);
  +        9..12:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).words[2] := (TUUID(Uuid^).words[2] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        14..17:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).words[3] := (TUUID(Uuid^).words[3] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        19..20:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[8] := (TUUID(Uuid^).bytes[8] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        21..22:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[9] := (TUUID(Uuid^).bytes[9] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        24..25:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[10] := (TUUID(Uuid^).bytes[10] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        26..27:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[11] := (TUUID(Uuid^).bytes[11] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        28..29:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[12] := (TUUID(Uuid^).bytes[12] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        30..31:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[13] := (TUUID(Uuid^).bytes[13] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        32..33:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[14] := (TUUID(Uuid^).bytes[14] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        34..35:
  +          if ishex(p^) then
  +          begin
  +            TUUID(Uuid^).bytes[15] := (TUUID(Uuid^).bytes[15] * 16) + hex2bin[Ord(p^)];
  +            inc(p);
  +            inc(pos);
  +          end else
  +          begin
  +            Result := False;
  +            Exit;
  +          end;
  +        36: if bracket then
  +            begin
  +              state := stEatSpaces;
  +              saved := stBracket;
  +            end else
  +            begin
  +              state := stEatSpaces;
  +              saved := stEnd;
  +            end;
  +      end;
  +    stBracket:
  +      begin
  +        if p^ <> '}' then
  +        begin
  +          Result := False;
  +          Exit;
  +        end;
  +        inc(p);
  +        state := stEatSpaces;
  +        saved := stEnd;
  +      end;
  +    stEnd:
  +      begin
  +        if p^ <> #0 then
  +        begin
  +          Result := False;
  +          Exit;
  +        end;
  +        Break;
  +      end;
  +  end;
  +  Result := True;
  +end;
  +
  +function UUIDToString(const g: TGUID): SOString;
  +begin
  +  Result := format('%.8x%.4x%.4x%.2x%.2x%.2x%.2x%.2x%.2x%.2x%.2x',
  +    [g.D1, g.D2, g.D3,
  +     g.D4[0], g.D4[1], g.D4[2],
  +     g.D4[3], g.D4[4], g.D4[5],
  +     g.D4[6], g.D4[7]]);
  +end;
  +
  +function StringToUUID(const str: SOString; var g: TGUID): Boolean;
  +begin
  +  Result := UuidFromString(PSOChar(str), @g);
   end;
   
   {$IFDEF HAVE_RTTI}
  
positive.code:   ParseString(PSOChar(path), true, False, self, [foCreatePath, foPutValue], TSuperObject.Create(Value));
  end;
  
  function TSuperObject.QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
  begin
    if GetInterface(IID, Obj) then
      Result := 0
  
negative.code:                     sep := yes;
                    end else
                      goto error;
               ',', '.':
                  begin
                    Inc(p);
                    state := stMs;
  