anchor.diff:      DB $0F, $45, $C2 // cmovnz eax, edx
     {$else .CPUX64}
       bsf rax, r9
  -    jz TThreadHeap.PenaltyGetSmall
  +    jz @requeue_line_loop_prefix
       btr r9, rax
       mov [R8].TK1LineSmall.Header.ItemSet.V64, r9
     {$endif}
  
positive.code:   end;
  end;
  
  function TThreadHeap.NewK1LineSmall(B16Count: NativeUInt): PK1LineSmall;
  var
    Index: NativeUInt;
    PoolSmall, Next: PK64PoolSmall;
  begin
    // take small pool
    repeat
      PoolSmall := QK64PoolSmall;
      if (PoolSmall <> nil) then
      begin
        if ({has available lines}PoolSmall.LineSet.V64 <> 0) then Break;
  
        // Full (QK64PoolSmall) --> (QK64PoolSmallFull)
        PoolSmall.Header.InQK64PoolSmallFull := True;
        // Dequeue
        Next := QK64PoolSmall.Queue.Next;
        QK64PoolSmall := Next;
        if (Next <> nil) then Next.Queue.Prev := nil;
        // Enqueue
        Next := QK64PoolSmallFull;
        QK64PoolSmallFull := PoolSmall;
        PoolSmall.Queue.Prev := nil;
        PoolSmall.Queue.Next := Next;
        if (Next <> nil) then Next.Queue.Prev := PoolSmall;
        // Continue;
      end else
      begin
        PoolSmall := NewK64PoolSmall;
        if (PoolSmall = nil{failure}) then
        begin
          Result := nil;
          Exit;
        end;
        Break;
      end;
    until (False);
  
    // reserve line
    Result := @PoolSmall.Lines[BitReserve(PoolSmall.LineSet)];
  
    // parameters
    Index := {BaseIndex}(B16Count - 1) + {IsFirst: Boolean}(Byte(Pointer(PoolSmall) = Pointer(Result)) shl 3);
    Result.Header.ItemSet.V64 := DEFAULT_BITSETS_SMALL[Index];
    Result.Header.Flags := {ModeSizeBits}(B16Count shl 4) + Index;
  
    // store line single
    FK1LineSmalls[B16Count] := Result;
    Result.Header.Queue.Prev := nil;
    Result.Header.Queue.Next := nil;
  end;
  
  function TThreadHeap.DisposeK1LineSmall(Line: PK1LineSmall): Integer;
  var
    Index: NativeUInt;
    PoolSmall: PK64PoolSmall;
  
negative.code:   // inline SpinLock
    ThreadHeap := UnknownThreadHeap;
    repeat
      if (ThreadHeap.LockFlags <> THREAD_HEAP_LOCKABLE) then SpinWait(ThreadHeap.LockFlags, THREAD_HEAP_LOCKED_BIT);
    until (THREAD_HEAP_LOCKABLE = AtomicCmpExchange(ThreadHeap.LockFlags, THRAED_HEAP_LOCKED, THREAD_HEAP_LOCKABLE));
    try
      // reget
      ThreadHeap.ErrorAddr := ErrorAddr;
  