anchor.diff:          end;
         end;
   
  -    var LOpComp : TPCOperationsComp;
  +      function DoAddOpData(AOpData : TOpData; var AFoundCounter : Integer; out AOperationResume : TOperationResume) : Boolean;
  +      begin
  +        Result := False;
  +        // Search by filter:
  +        if ((Not ASearchBySender) Or (ASearchSender = AOpData.Data.account_sender))
  +           and ((Not ASearchByTarget) Or (ASearchTarget = AOpData.Data.account_target))
  +           and ((Not ASearchByGUID) Or (EqualGUIDs(ASearchGUID,AOpData.Data.guid)))
  +           and ((Not ASearchByDataSequence) Or (ASearchDataSequence = AOpData.Data.dataSequence))
  +           and ((Not ASearchByDataType) Or (ASearchDataType = AOpData.Data.dataType))
  +        then begin
  +          if (AFoundCounter>=AStartOperation) And (AFoundCounter<=AEndOperation) then begin
  +            If TPCOperation.OperationToOperationResume(ABlock_number,AOpData,False,AOpData.SignerAccount,AOperationResume) then begin
  +              AOperationResume.Balance:=-1;
  +              Result := True;
  +            end;
  +          end;
  +          inc(AFoundCounter);
  +        end;
  +      end; // For LList...
  +
  +
  +    var LOpComp, LMemPool : TPCOperationsComp;
         LOperation : TPCOperation;
         LOpData : TOpData;
         LOperationResume : TOperationResume;
  
positive.code:     end;
      LFirst_Block_Is_Unknown := False;
      LStartBlock := LAccount.GetLastUpdatedBlock;
      if LStartBlock>=ASender.Node.Bank.BlocksCount then Dec(LStartBlock); // If its updated on mempool, don't look the mempool
    end;
  
    LOperationsResumeList := TOperationsResumeList.Create;
    try
      DoFindFromBlock(LStartBlock,
        LSearchedAccount_number,
        LStartOperation, LStartOperation + LMaxOperations,
        LMaxDepth, LFirst_Block_Is_Unknown,
        LSearchBySender, LSender,
        LSearchByTarget, LTarget,
  
negative.code:       Try
          LList := TList<Cardinal>.Create;
          try
            // Mempool
            if ABlock_number>=ASender.Node.Bank.BlocksCount then begin
              // Search mempool
              LMemPool := ASender.Node.LockMempoolRead;
              try
                LMemPool.OperationsHashTree.GetOperationsAffectingAccount(ASearchedAccount_number,LList);
                LFound_in_block := False;
                // Reverse order:
                for i := LList.Count - 1 downto 0 do begin
                  LOperation := LMemPool.Operation[LList.Items[i]];
                  if LOperation is TOpData then begin
                    //
                    LOpData := TOpData( LOperation );
                    if DoAddOpData(LOpData,LFoundCounter,LOperationResume) then begin
                      LOperationResume.NOpInsideBlock:=LList.Items[i];
                      LOperationResume.Block:=ASender.Node.Bank.BlocksCount;
                      AOperationsResumeList.Add(LOperationResume);
                      LFound_in_block := True;
                    end;
                  end;
                end; // For LList...
                If (Not LFound_in_block) And (AFirst_Block_Is_Unknown) then begin
                  ABlock_number := ASender.Node.Bank.BlocksCount - 1;
                end else begin
                  ABlock_number := LMemPool.PreviousUpdatedBlocks.GetPreviousUpdatedBlock(ASearchedAccount_number,ASender.Node.Bank.BlocksCount - 1);
                end;
              finally
                ASender.Node.UnlockMempoolRead;
              end;
            end;
  
  
  
            LLast_block_number := ABlock_number+1;
            while (LLast_block_number>ABlock_number) And (AAct_depth>0)
              And (ABlock_number >= (ASearchedAccount_number DIV CT_AccountsPerBlock))
  