This function is to retrieve the mail:password base from the logs.

1. Buy a license via our Telegram bot: https://t.me/GoldenEagleTeamRobot.
2. After payment the bot will issue your license key.
3. Create a file named key.txt in the program folder and paste your key into it.
4. On first run the program will activate the key and bind it to your PC by UUID.

You probably have the wrong time in your system. Synchronize it in the time zone settings. After that everything should work.

1. The code automatically processes the folder selected by the user, finds all log files containing lines with logins and passwords (in the mail:pass format), extracts them using regular expressions, removes duplicates, and saves the result to a file.
2. During processing, invalid lines are discarded, including:
3. * entries containing the word “UNKNOWN”;
4. * lines where the login is shorter than 3 or longer than 40 characters;
5. * lines where the password is shorter than 3 or longer than 50 characters.

1. The code automatically processes the folder selected by the user, finds all log files containing lines with logins and passwords (in the Login:pass format), extracts them using regular expressions, removes duplicates, and saves the result to a file.
2. During processing, invalid lines are discarded, including:
3. * entries containing the word “UNKNOWN”;
4. * lines where the login is shorter than 3 or longer than 40 characters;
5. * lines where the password is shorter than 3 or longer than 50 characters.

1. Collects the discord token from all logs.

1. Collects strings with FTP data.
2. During processing, invalid lines are discarded, including:
3. * Entries containing the word “UNKNOWN”;
4. * Search by FTP address
5. * Search by IP address

1. The code recursively scans the folder selected by the user. The search is performed using regular expressions that extract data such as URL, Login, and Password.
2. During filtering, “bad” data is removed, including:
3. * lines where the login or password contains the word “UNKNOWN”;
4. * logins shorter than 3 or longer than 40 characters;
5. * passwords shorter than 3 or longer than 50 characters;

1. The program recursively scans all subdirectories and files, comparing their names with the fragment entered by the user (e.g., wallet, chrome, cookies). All matches are added to the list.
2. After the search is complete, the user selects the copy mode:
3. Mode 1 (Full structure) — the entire directory structure in which the desired item is found is copied.
4. Mode 2 (Only found folder) — only the found files or folders are copied without unnecessary levels.
5. If there are several matches with the same names, they are numbered (e.g., 1_wallet, 2_wallet). When the search is complete, the number of items found, the execution time, and the path to the saved results are displayed.

1. This code performs a mass search for URL:login:password data in the user-selected log folder and forms a single database of found strings.
2. The program recursively scans all files containing the word passwords.txt and uses regular expressions to extract combinations of the form: ULP
3. Before saving, each record found is filtered — strings containing “UNKNOWN”, logins and passwords that are too short or too long (less than 3 or more than 60 characters), as well as records with extra spaces are removed.

This code extracts login:password pairs from text logs, applying filtering by domains and string structure.

1. What the code does:
2. Filters domains — the user selects the mode:
3. exclude specified domains (blacklist),
4. collect only specified domains (whitelist),
5. or collect all e-mails.
6. Searches for lines containing email addresses and passwords in .txt files located in the selected folder (and subfolders).
7. Skips junk lines (without @, with inappropriate length, too long passwords, UNKNOWN, etc.).
8. Checks the email format using a regular expression.
9. Displays statistics (number of lines, files, pairs found, and processing time).
10. The following lines are considered invalid:
11. Those that do not contain @.
12. Those without separators (:, |, space).
13. Those where the email address does not validate against the [email protected] template.
14. Those with UNKNOWN in the password.
15. With a password longer than 100 characters.
16. That did not pass the domain filter (for example, gmail.com is prohibited in blacklist mode).

1. What the code does:
2. Collects login:password pairs from all .txt files in the selected folder and subfolders.
3. Discards junk lines, leaving only valid pairs where the login and password:
4. do not contain @ (i.e., they are not e-mail addresses),
5. do not contain UNKNOWN,
6. are between 1 and 100 characters long.
7. Uses multithreading for accelerated file processing.
8. Displays statistics — the number of files processed, lines, and pairs found.
9. Bad lines:
10. Do not contain separators (:, |, space).
11. Do not contain at least two fields after separation.
12. The login or password contains @ (e-mail, not suitable for this function).
13. The login or password is empty.
14. The login or password contains the word UNKNOWN (in any case).
15. The login or password is longer than 100 characters.

1. What the code does:
2. Searches for all .txt files in the selected folder and subfolders.
3. Extracts possible phone numbers and passwords from each line.
4. Checks that the phone number matches the format +123456789 (7–16 digits) and that the password is not empty, does not contain UNKNOWN, and is not longer than 100 characters.
5. Cleans the number (removes spaces and brackets).
6. Saves all found pairs to the temp.txt file via stream recording.
7. Works multithreaded to speed up processing.
8. Displays the progress and total number of records found.
9. Bad lines:
10. Without separators (:, |, space).
11. Where the phone number does not match the format (+ and 7–16 digits).
12. Where the password is empty, too long, or contains UNKNOWN.

This function scans and extracts login:password pairs (or full lines) from large log bases according to user-defined filters and save modes.

1. Prompts the user to choose a save mode:
   • 1 — saves login:password pairs with basic cleaning.
   • 2 — saves the full line (e.g. url:login:pass) with normalization.
   • 3 — saves the line as-is (no filters, only checks for separators).
   • 4 — saves the line as-is but replaces all spaces, :, and | with a single :.
2. Lets the user select a folder with log files — recursively scans all subfolders and collects all .txt files.
3. Prompts for one or more keywords (e.g. steam, wp-admin), then searches for lines containing these keywords in the logs.
4. Parses matching lines:
   • Checks for separators (:, |, or space).
   • Extracts login and password (or keeps the entire line, depending on the mode).
   • Skips lines containing UNKNOWN or fields longer than 100 characters.

This function extracts FTP credentials (host:port:login:password) from text log files, filtering out invalid or local IPs.

1. Checks if the host is a valid domain or public IP (ignores local, loopback, and private IP ranges).
2. Parses each line to detect possible FTP entries:
   • Lines containing ftp:// are processed with full URL parsing.
   • Lines with plain IPs or the word ftp are handled in a general format.
3. Valid entries must include a host, login, and password — each less than 100 characters and without UNKNOWN.
4. Invalid or malformed lines (too long, missing parts, invalid host, or local IPs) are skipped.
5. After processing:
   • The user can choose to upload or save results locally.
   • Duplicates are removed, and a final file with unique entries is saved in a timestamped folder Result_YYYY_MM_DD_HH_MM_SS.
6. Bad (ignored) lines:
   • Lines longer than 200 characters.
   • Lines without enough fields (host, login, password).
   • Lines containing UNKNOWN.
   • Lines with invalid hostnames or private/local IPs.

This function allows the user to delete specific files or file types from a chosen folder and all its subfolders.

1. The console prompts the user to enter file extensions or exact file names (e.g. *.exe *.bat UserInformation.txt).
2. Each entered value is validated:
   • Accepted formats: *.extension (e.g. *.txt) or filename.extension (e.g. data.log).
   • Invalid formats are rejected with a warning.
3. The user selects a folder using the directory chooser dialog.
4. The program recursively searches through all subfolders for files matching the given extensions or names.
5. All found files are deleted automatically.
6. The console shows:
   • The progress of the deletion process for each element.
   • The number of deleted files.
   • The total working time.

This function checks FTP credentials from a provided .txt base file and categorizes them as valid or invalid.

1. Reads each line from the selected FTP base file and extracts IP, port, username, and password.
2. Attempts to connect to each FTP server using the provided credentials.
3. If the connection is successful:
   • Lists all files available on the FTP server.
   • Saves the credentials and file list to Goods_Full.txt and Goods_ULP.txt.
4. If the connection fails:
   • The failed credentials and error details are saved to BAD_log.txt and BAD_ULP.txt.
5. Uses multithreading to check multiple FTP accounts simultaneously for faster performance.
6. Displays progress and final statistics: number of successful (Good) and failed (Bad) FTP connections.
7. Results are stored in a timestamped folder inside the FTP directory.

This function automates FTP exploitation by checking servers, deleting index files, and uploading local files.

1. Reads FTP credentials from a user-selected .txt file (format: ip;port;username;password).
2. Connects to each FTP server and checks for write permissions.
3. Deletes index.php and index.html files found on the server.
4. Uploads all files from a specified local directory to the FTP server.
5. Uses multithreading to process multiple servers simultaneously.
6. Logs actions:
   • Successful uploads and deletions in upload_log.txt and Goods_ULP.txt.
   • Failed attempts in delete_log.txt and BAD_log.txt.
7. Excludes certain directories from processing (e.g., logs, wp-admin, js, css).
8. Displays final statistics: number of successful (Good) and failed (Bad) FTP connections.

This function performs automated WordPress login checks and privilege detection.

1. Reads WordPress credentials from a user-selected .txt file (format: URL:http:username:password).
2. Skips invalid URLs or localhost/internal addresses.
3. Attempts login up to 3 times per site using wp-login.php.
4. Checks if the user can access plugins.php (owner/admin rights).
5. Uses multithreading to process multiple WordPress sites concurrently.
6. Logs results:
   • Successful logins in Goods_Full.txt and Goods_ULP.txt.
   • Sites with admin rights in Owner.txt.
   • Failed logins in Bad_log.txt and Bad_ULP.txt.
7. Displays counts of good logins, admin-accessible sites, and failed logins.

This function automates WordPress login checks, plugin installation, and activation.

1. Reads WordPress credentials from a .txt file (format: URL:http:username:password).
2. Skips invalid URLs and localhost/internal addresses.
3. Attempts login using wp-login.php for each site.
4. Checks if the user can access plugins.php (admin rights).
5. If admin access exists, uploads and attempts to activate a plugin from a user-specified ZIP file.
6. Uses multithreading to process multiple WordPress sites concurrently.
7. Logs results:
   • Successful logins in Goods_Full.txt and Goods_ULP.txt.
   • Admin-accessible sites in Owner.txt.
   • Sites with plugin successfully installed in Plugin_Install_Log.txt.
   • Failed logins in Bad_log.txt and Bad_ULP.txt.
8. Clears console periodically and displays progress messages with color-coded output.

This section implements an asynchronous cPanel/Webmail checker using aiohttp and asyncio.

1. Reads credentials from a .txt file (format: URL:http:ignored_field:username:password).
2. Skips invalid URLs and internal addresses like localhost or 127.0.0.1.
3. Logs into cPanel/Webmail via /login URL using async requests with SSL verification disabled.
4. Handles redirects and checks the final page's <title> to determine the type:
   • "cPanel" → cPanel account
   • "Webmail" or "Mail" → Webmail
   • "Login" → Invalid credentials
   • Other → Unknown page type
5. Writes results to multiple log files:
   • Valid cPanel accounts: Cpanel_ULP.txt and Cpanel_Full.txt
   • Valid Webmail accounts: Webmail_ULP.txt
   • Failed logins or unknown pages: BAD_LOG.txt and BAD_ULP.txt
6. Limits simultaneous requests with asyncio.Semaphore(150) to avoid overload.
7. Retries failed requests up to 2 times for SSL errors, timeouts, or other exceptions.
8. Creates timestamped result directories automatically in Cpanel/Result_YYYY-MM-DD_HH-MM-SS.
9. Ensures graceful handling of malformed lines in the input file, logging them as invalid format.

This section is an asynchronous phpMyAdmin checker using aiohttp and asyncio.

1. File Parsing: Reads credentials in URL:login:password format. If the URL doesn't start with http, it automatically prepends https://.
2. CSRF Handling: Requests the main page to extract the CSRF token (input field named token) required for login.
3. phpMyAdmin Detection:
   • Checks if the site contains "phpMyAdmin" in its content.
   • Handles redirects recursively and logs them.
   • Handles 404 responses separately.
4. Login Attempts:
   • Posts pma_username, pma_password, and token to the login page.
   • Retries up to 3 times for timeouts or failures.
   • Considers a login successful if the page contains 'logout', 'logout.php', or title="Log out".
5. Async Processing: Uses asyncio.Semaphore to limit concurrency and aiofiles for asynchronous file writing.
6. File Logging:
   • Valid credentials → valid_credentials.txt
   • Invalid credentials → invalid_credentials.txt
   • Not found sites → not_found.txt
   • Unreachable sites → unreachable.txt
7. Character Encoding: Uses chardet to auto-detect the encoding of the input file.
8. Logging: Uses colorlog for color-coded console logs and standard logging to save logs to processing_log.txt.
9. Folder Management: Creates timestamped output directories for each run to organize results.
10. User Input: Asks for:
    • The path to the database file
    • Number of threads (concurrent requests, recommended 100-150)

Brief: multithreaded SSH checker that tries credentials from a list, logs successes and failures, and gathers basic info (permissions, SFTP file list).

1. Reads lines in host:port:username:password format from a user-selected file.
2. Uses a worker queue and many threads to attempt SSH connections via paramiko.
3. On success: records host:username:password, retrieves permissions (via id) and attempts SFTP listing; writes extended info to logs.
4. If initial credentials fail, attempts a set of standard creds (e.g. root:root) before marking as bad.
5. Maintains counters for total/processed/good/bad, runs a periodic progress monitor, and saves logs under logs_SSH/.
6. Input validation, per-line error handling, and thread-safe logging are included; default SSH port used is 22.

Brief: Discord token checker using SOCKS5 proxies with multithreading, logging, and optional proxy validation.

1. Disables SSL warnings and defines a list of USER_AGENTS for requests.
2. random_hex() generates random 32-character hexadecimal strings for cookies.
3. get_headers(token) prepares HTTP headers including authorization, super properties, and cookies.
4. log_write() prints messages to console and appends them to a log file.
5. check_proxy(proxy) tests if a SOCKS5 proxy works with Discord API endpoints.
6. check_token(args) attempts to verify a Discord token via the API, rotating proxies on failure, handling rate limits (HTTP 429), and logging results.
7. Main function :
   • Prompts for token file and proxy file paths.
   • Optionally verifies proxies first using ThreadPoolExecutor.
   • Spawns multiple threads to check tokens, rotating through available proxies.
   • Logs valid tokens and full info (username, email, MFA, ID) to result files.

Key features: multithreading, proxy rotation, rate-limit handling, random headers, and detailed logging of valid/invalid tokens.

Brief: Asynchronous proxy checker using aiohttp and aiohttp_socks with multiple protocols (HTTP, HTTPS, SOCKS4, SOCKS5).

1. Defines constants for concurrency, timeout, and default headers.
2. Supports multiple default IP-check services (ip-api.com, ipinfo.io, etc.) with per-service validators.
3. Global state for validated logs, working proxies by protocol and service, and bad proxies.
4. parse_proxy_line() and format_proxy() handle multiple proxy formats (ip:port, ip:port:user:pass, http://ip:port, proto://user:pass@ip:port, etc.).
5. check_single_protocol():
   • Parses proxy line, builds a URL depending on protocol.
   • Uses ProxyConnector for SOCKS and TCPConnector for HTTP/HTTPS.
   • Checks the proxy against all target services asynchronously.
   • Records results as success/fail, and collects working proxies by protocol and service.
6. User input functions:
   • Load proxy file.
   • Select protocols (HTTP, HTTPS, SOCKS4, SOCKS5, or all).
   • Optionally set a custom URL for checking.
   • Choose output format for proxies (ip:port, ip:port:user:pass, etc.).
7. Main entry :
   • Prints header.
   • Loads proxies and user options.
   • Runs asynchronous check and saves results.

Key features: high concurrency, protocol detection, multi-service validation, flexible proxy input/output formats, and detailed result logging.

Brief: Asynchronous proxy grabber using aiohttp that fetches proxies from multiple public sources, validates, deduplicates, and saves them.

1. Public sources: Lists of URLs per protocol (http, https, socks4, socks5).
2. Global state:
   • proxies – stores proxies per type in sets.
   • raw_stats – keeps counters: fetched, duplicates, filtered, final.
3. Local IPs and bad ports filtering:
   • LOCAL_IPS regex patterns exclude private and reserved ranges.
   • BAD_PORTS set excludes common unsafe or restricted ports.
4. extract_proxies(text) – regex-based extraction of IP:port and optionally user:pass.
5. is_valid(proxy) – validates proxy:
   • Port > 80 and not in BAD_PORTS.
   • IP not in private/reserved ranges.
6. deduplicate(proxies_set) – removes duplicates based on IP:port only.
7. fetch_ptype(session, ptype, url) – asynchronously fetches proxies for a given type from a URL, updates counters and sets, prints progress.
8. run_grabber() – main async function:
   • Displays header.
   • Runs fetch tasks for all protocols and sources concurrently.
   • Deduplicates, filters, and saves proxies to proxies/{ptype}.txt.
   • Prints final statistics per protocol and total usable proxies.

Key features: high concurrency, multi-source fetching, IP and port filtering, deduplication, organized output per protocol, and detailed stats.

Brief: A set of utility functions for removing duplicates from large files using either memory or disk-based approaches with pre-checks for RAM and disk space.

1. System checks:
   • check_memory_usage(required_memory_mb) – ensures enough RAM is available before memory-heavy operations.
   • check_disk_space(required_space_mb, directory) – ensures sufficient free disk space for disk-based duplicate removal.
2. Temp folder management:
   • clean_temp_folder(temp_dir) – deletes all files and subdirectories in a temporary folder.
3. File handling:
   • try_open_file(file_path, mode, retries, delay) – attempts to open a file multiple times if locked by another process.
   • generate_output_filename(input_file, output_dir) – generates a consistent output filename for the results.
4. Duplicate removal methods:
   • remove_duplicates_memory(input_file, output_dir)
     • Loads the entire file into memory as a set to remove duplicates.
     • Requires sufficient RAM (approx. twice the file size).
     • Writes sorted unique lines to an output file.
   • remove_duplicates_disk(input_file, output_dir)
     • Splits the file into sorted parts (e.g., 10,000 lines each) stored on disk.
     • Merges the sorted parts using heapq.merge to efficiently remove duplicates with minimal memory.
     • Suitable for very large files that cannot fit in memory.
5. Results reporting:
   • print_results(total_lines, unique_count, duplicates_count, output_file, start) – prints processing statistics including time elapsed.
6. Main loop for user interaction:
   • Provides a menu to choose memory-based, disk-based, or exit.
   • Uses file dialogs for input file selection and output directory.
   • Performs API logging if the user is paid or free.

Key features: robust duplicate removal, memory/disk optimization, progress reporting, automatic temp cleanup, retry handling for file locks, and user-friendly file selection.

Brief: This section handles combining multiple text files into a single file while preserving encoding and counting lines.

1. File processing function:
   • process_file(file, output_file, line_count) – reads a file in binary mode, decodes each line as UTF-8 (ignoring errors), writes it to the output file, and updates the total line count.
   • Ensures robust handling with try-except to catch read/write errors for individual files.
2. User interaction:
   • Uses Tkinter file dialogs for selecting multiple input files (askopenfilenames) and specifying a combined output file (asksaveasfilename).
   • Prints each file being processed for transparency.
3. Time tracking:
   • Calculates elapsed time for the entire file combination process and outputs it in hours, minutes, and seconds.
4. Output and feedback:
   • Reports the total number of lines in the combined file.
   • Confirms successful creation of the new file.
5. Technical notes:
   • Handles UTF-8 decoding errors gracefully.
   • Writes the output in binary mode to ensure compatibility with non-UTF-8 characters.
   • Writes a newline at the end of each file’s content to separate them.

Key features: multi-file combination, line counting, UTF-8-safe encoding, user-friendly dialogs, progress reporting, and optional API usage tracking.

Brief: This section handles splitting a large text file into smaller files with a specified number of lines per file.

1. File splitting function:
   • split_file(file_path, lines_per_file, output_dir) – reads the entire input file into memory, then splits it into chunks of lines_per_file lines.
   • Each chunk is written to a new file named {original_filename}_partX.txt in the specified output directory.
2. User interaction:
   • Uses Tkinter file dialogs for selecting input files (askopenfilenames) and specifying an output directory (askdirectory).
   • If the user does not select a file or directory, default values are used.
   • Prompts the user to enter the number of lines per split file.
3. Time tracking:
   • Measures and outputs the elapsed time for the splitting operation in hours, minutes, and seconds.
4. Output and feedback:
   • Reports the directory where the split files were saved.
   • Prints completion message and processing duration.
5. Technical notes:
   • Reads the file in UTF-8 with error ignoring to handle malformed lines.
   • Automatically creates the output directory if it doesn’t exist.
   • Supports multiple input files, but currently only processes the first selected file.

Key features: user-friendly file selection, line-based splitting, UTF-8 safe processing, output in organized parts, and elapsed time reporting.

Brief: This section provides a "mail:pass" string normalizer that reads multiple text files, validates and standardizes email:password pairs, and writes them to a single output file.

1. Line processing function:
   • process_and_writes(input_file, output_file, processed_lines, total_lines) reads each line from the input file.
   • It skips lines containing "UNKNOWN" or "unknown".
   • Replaces separators like ; and | with : and collapses whitespace into :.
   • Validates that the line matches the mail:pass format with at least 4 characters for both email and password, and email starting with an alphanumeric character.
   • Writes only valid lines to the output file and updates counters every 1000 lines.
2. User interface:
   • Uses Tkinter file dialogs for selecting multiple input files and choosing the output file name.
   • Progress is displayed in real-time with a line counter.
3. Time tracking:
   • Calculates and prints elapsed time in hours, minutes, and seconds.
4. Output and feedback:
   • Prints total rows processed and confirms successful creation of the new file.
   • Ensures robust handling of UTF-8 encoding and ignores errors for malformed lines.

Key features: multi-file processing, automatic normalization to mail:pass format, real-time progress display, UTF-8 safe reading/writing, and final summary with elapsed time.

Brief: This section implements an email sorting tool that organizes mail:pass lines from text files into separate files based on domains, supporting simple, advanced, and custom sorting modes.

1. Popular Domains:
   • A set of well-known email providers (gmail.com, yahoo.com, outlook.com, etc.) is used for "simple" sorting mode.
2. Line Processing:
   • process_and_write reads each line from input files, normalizes separators, and validates mail:pass format.
   • Valid entries are buffered per domain; unrecognized domains go to other.txt in simple mode.
   • Advanced mode creates files for all domains, and custom mode allows the user to specify which domains to sort.
   • Domain-specific buffers are written to separate files in the selected output folder.
3. User Interaction:
   • Uses Tkinter for file selection and output folder selection.
   • Mode selection is done via console input with options: simple, advanced, custom, exit.
   • Custom mode prompts the user to enter a comma-separated list of domains to sort.
4. Output and Statistics:
   • Prints total lines processed, files created, and working time in hours, minutes, and seconds.
   • Handles UTF-8 encoding safely and ignores malformed lines.

Key Features: multi-file domain sorting, mode-based filtering (popular, all, custom), automatic file creation per domain, real-time processing statistics, and UTF-8 safe reading/writing.

Brief: This section implements a string randomizer tool that shuffles lines from multiple text files and writes them into a new output file.

1. Line Aggregation:
   • randomize_and_write reads all lines from the selected input files and stores them in a list.
2. Randomization:
   • Uses random.shuffle to jumble all the lines together.
3. Output File Creation:
   • Writes the shuffled lines into a new file specified by the user via a file save dialog.
   • UTF-8 encoding with errors ignored ensures that malformed characters do not break the process.
4. User Interaction:
   • Hidden Tkinter window is used to select multiple input files and specify the output file.
   • If no files or output file are selected, the program exits gracefully.
5. Statistics:
   • Displays working time in hours, minutes, and seconds.
   • Confirms the creation of the shuffled output file.

Key Features: multi-file input, randomized output, UTF-8 safe processing, Tkinter file dialogs, paid/free user API logging, and elapsed time tracking.

Brief: This section provides a filtered email processor that reads a file with email:password entries and outputs only lines matching specific domain criteria, with multithreading for speed.

1. Encoding Detection:
   • Uses chardet to read the first 10 KB of the file and determine the character encoding automatically.
2. Email Filtering:
   • Uses a regex pattern email_pass_pattern to validate the email:password format.
   • Domain matching is performed using Unix-style wildcards with fnmatch.
   • Supports two modes:
     • Mode 1: Keep only lines that match the user-specified domains.
     • Mode 2: Keep only lines that do not match the specified domains.
3. Multithreaded Processing:
   • Uses ThreadPoolExecutor with a batch size of 5000 lines and 8 threads by default to speed up filtering on large files.
   • Each line in a batch is processed concurrently with process_line.
4. Progress Feedback:
   • Displays a progress bar using tqdm showing processed lines in real time.
5. Output Handling:
   • Writes filtered results to a new UTF-8 encoded file.
   • Tracks the number of processed and saved lines and returns processing statistics, including elapsed time and file encoding.
6. Error Handling:
   • Skips lines that don’t match the expected pattern.
   • Raises an error if the file encoding cannot be determined.

Key Features: automatic encoding detection, regex-based email validation, multithreaded batch processing, domain-based filtering, progress bar, and full statistics on processed vs saved lines.