hmRemi/README.md

## README.md

      
    Raw
  

              README.md
            
          
    Discord Guild ID Hash Targeter Script

Discord no longer provides the tags feature to new servers. This could change, so I'm keeping this active and seeking other ways to get a tag server. I still recommend trying create guilds within the specified hash ranges. Please support by starring this gist and joining our Discord (link below).
Also, selling a script for a fully customizable rotating clan tag. (colors and badge icon - join discord to buy)
Version: 1.2.5 (as per CONFIG.SCRIPT_VERSION in the script)

Discord: https://discord.gg/wSWYhQMdbA | @ziue

Telegram: https://t.me/reveredev/

Wound: https://wound.lol

Star our other project too!:

https://github.com/RevereInc/alley-practice
Preview: https://www.youtube.com/watch?v=E1wusGbNnG4 - releasing this version with ratelimit bypass at 200 stars
A JavaScript tool designed to run in a Discord client's developer console environment (typically one enhanced by client modifications). It automates the creation and inspection of Discord guilds to find those whose server IDs, when combined with a specific salt and hashed using MurmurHash3, fall into predefined numerical ranges.
Found guilds that meet the criteria are kept (and logged); others are automatically deleted after a short delay.

⚠️ IMPORTANT WARNINGS & DISCLAIMER ⚠️


Use Responsibly: This script automates actions against the Discord API at a potentially high rate. Excessive use WILL lead to API rate-limiting for your account, and could potentially lead to other actions from Discord, including account suspension.
Discord Terms of Service: Be aware that automating user actions might be against Discord's Terms of Service or API guidelines. You are solely responsible for how you use this script.
No Guarantees: This script is provided as-is. There's no guarantee it will find what you're looking for, or that it will always work due to potential Discord client updates.
Educational Purposes: This script is primarily intended for educational and research purposes to understand API interactions and hashing algorithms.


Prerequisites


Modded Discord Client Environment: This script requires a function named findByProps to be available in the global scope of the developer console. This function is typically provided by Discord client modifications like Vencord, BetterDiscord, or similar tools that expose Discord's internal Webpack modules. It will NOT work in a standard browser console on discord.com or a vanilla Discord client.
Developer Console Access: You need to be able to open and use your Discord client's developer console (usually Ctrl+Shift+I or Cmd+Opt+I).


How to Use


Setup Vencord: Install the ConsoleShortcuts plugin from vencord
Create a server: Manually create a discord server, template does not matter.
Copy the Script: Copy the entire discord-guild-tag-finder.js code.
Open Discord Console: Open your Discord client and then open its developer console.
Paste and Run Initialization:

Paste the script into the console and press Enter. You'll see some initial loading messages.
Then, type the following command to initialize the script and its required Discord modules:
GuildTagFinder.initialize();

If initialization is successful, you'll see a confirmation message. If it fails, it will likely be due to findByProps not being available or Discord's internal modules having changed.


(Optional) Enable Debug Mode: For more detailed logging output, you can enable debug mode:
GuildTagFinder.setDebugMode(true);
To disable it:
GuildTagFinder.setDebugMode(false);

Start the Script:
GuildTagFinder.start();
The script will now begin creating guilds, checking their IDs, and logging its progress.
Stop the Script: To stop the script at any time:
GuildTagFinder.stop();
This will clear the creation interval and log a summary of attempts and finds.


Configuration

The script's behavior can be customized by modifying the CONFIG object at the top of the script before running GuildTagFinder.initialize(). Key configuration options include:

ATTEMPT_INTERVAL_MS: The time (in milliseconds) between attempts to create a guild.

Important: Setting this too low will quickly lead to rate-limiting. Default is 6000 (6 seconds).


DELETE_DELAY_MS: The delay (in milliseconds) before a non-target guild is deleted. Default is 3000 (3 seconds).
SERVER_NAME_PREFIX: The prefix used for naming the guilds created by the script.
HASH_SALT_PREFIX: The salt string prefixed to the guild ID before hashing.

Changing this value will completely change the resulting hashes and thus the "tags" you are searching for.


HASH_MODULO: The modulo value applied to the hash result. This determines the upper bound of the possible hash values (0 to HASH_MODULO - 1).
TARGET_HASH_RANGES: An array of objects defining the desired hash ranges. Each object should have min and max properties.

Example: [{ min: 10, max: 19 }, { min: 60, max: 99 }]


GUILD_TEMPLATE: The template object used for creating new guilds.
LOGGER_OPTIONS.USE_TIMESTAMPS: Set to true to include timestamps in log messages.
LOGGER_OPTIONS.DEBUG_MODE: Set to true for verbose debug logging (can also be toggled with GuildTagFinder.setDebugMode()).


How It Works Briefly


Initialization (GuildTagFinder.initialize()): Uses the environment-provided findByProps function to locate Discord's internal functions for creating and deleting guilds.
Starting (GuildTagFinder.start()): Begins an interval timer.
Guild Creation Cycle:

A new Discord guild (server) is created using a basic template.
The unique ID of this new guild is retrieved.
A string is constructed: CONFIG.HASH_SALT_PREFIX + newGuild.id.
This string is hashed using the murmurhash3_32_gc algorithm.
The hash result is taken modulo CONFIG.HASH_MODULO.


Target Check:

The resulting number is checked against the ranges defined in CONFIG.TARGET_HASH_RANGES.
If it matches a target range: The guild is logged as a "find" and is not deleted. The script continues searching.
If it does not match: The guild is scheduled for deletion after CONFIG.DELETE_DELAY_MS.


Loop: The process repeats every CONFIG.ATTEMPT_INTERVAL_MS until GuildTagFinder.stop() is called.


Troubleshooting & Support

If you run into any issues while using this script, have questions, or would like to provide feedback, please consider the following:


Double-Check Prerequisites & Usage: Many common issues can be resolved by ensuring:

You are using a modded Discord client environment where findByProps is available (e.g., Vencord, BetterDiscord).
You have correctly followed the How to Use steps, especially the GuildTagFinder.initialize(); command before GuildTagFinder.start();.
There are no obvious error messages in the developer console that indicate a problem with your Discord client or the script's initialization.


Check for Script Updates: Ensure you are using the latest version of this script from the Gist, as updates may fix known bugs or adapt to Discord changes.


Reporting Issues:


For general questions, bug reports, or public discussion: The best way is to leave a comment directly on this Gist page. This allows others who might have the same issue to see the discussion and potential solutions.
When reporting an issue, please try to include:

The Script Version you are using (e.g., 1.2.0).
The Discord Client you are using (e.g., Vencord, BetterDiscord version).
A clear description of the problem.
Steps to reproduce the issue, if possible.
Any relevant error messages shown in the console (screenshots can be helpful).


For direct contact or other inquiries: You can reach out to me on Discord: ziue or https://discord.gg/wSWYhQMdbA


Please remember that support is provided as time permits. Clear and detailed issue reports are much appreciated and will help in addressing the problem more effectively!


## discord-guild-tag-finder.js
/**
 * @file discord-guild-tag-finder.js
 * @version 1.2.5
 * @description Automates the creation and checking of Discord guilds to find ones with specific ID-based hash characteristics.
 * @author Revere Development
 *
 * @warning This script interacts with the Discord API in ways that might be considered
 * abusive if not used responsibly. Excessive use can lead to rate-limiting,
 * account suspension, or other actions by Discord. Use at your own risk and
 * be mindful of the Discord Terms of Service and API usage guidelines.
 * This script is intended for educational and research purposes.
 *
 * @dependency This script relies on a `findByProps` function being available in its
 * execution environment (e.g., Discord client console with developer tools
 * enhanced by a client mod like Vencord, BetterDiscord, etc.).
 * If `findByProps` is not found, the script will not initialize.
 */

const GuildTagFinder = (() => {
    'use strict';

    const CONFIG = {
        SCRIPT_VERSION: "1.2.5",
        ATTEMPT_INTERVAL_MS: 65 * 1000,
        DELETE_DELAY_MS: 3 * 1000,
        SERVER_NAME_PREFIX: "TagFinder Server #",
        HASH_SALT_PREFIX: "2025-02_skill_trees:",
        HASH_MODULO: 10000,
        TARGET_HASH_RANGES: [
            { min: 10, max: 19 },
            { min: 60, max: 99 },
            { min: 150, max: 199 },
            { min: 600, max: 999 },
            { min: 1500, max: 1999 },
            { min: 2250, max: 2499 },
            { min: 2750, max: 2999 },
        ],
        GUILD_TEMPLATE: {
            id: "CREATE",
            label: "Create My Own",
            channels: [],
            system_channel_id: null,
        },
        LOGGER_OPTIONS: {
            USE_TIMESTAMPS: false,
            DEBUG_MODE: false,
        }
    };

    const Logger = {
        _log: (level, color, ...messages) => {
            const prefix = CONFIG.LOGGER_OPTIONS.USE_TIMESTAMPS ?
                `[${new Date().toISOString()}] [${level}]` :
                `[${level}]`;
            console.log(`%c${prefix}`, `color: ${color}; font-weight: bold;`, ...messages);
        },
        info: (...messages) => Logger._log('INFO', 'dodgerblue', ...messages),
        success: (...messages) => Logger._log('SUCCESS', 'green', ...messages),
        warn: (...messages) => Logger._log('WARN', 'orange', ...messages),
        error: (...messages) => Logger._log('ERROR', 'red', ...messages),
        debug: (...messages) => {
            if (CONFIG.LOGGER_OPTIONS.DEBUG_MODE) {
                Logger._log('DEBUG', 'purple', ...messages);
            }
        },
    };

    /**
     * Calculates a 32-bit MurmurHash3.
     * This is a common non-cryptographic hashing algorithm.
     * @param {string} key The string to hash.
     * @param {number} [seed=0] An optional seed.
     * @returns {number} The 32-bit hash, unsigned.
     */
    function murmurhash3_32_gc(key, seed = 0) {
        let currentHash = seed;
        const textEncoder = new TextEncoder();
        const keyBytes = textEncoder.encode(key);
        const numBytes = keyBytes.length;
        const numBlocks = Math.floor(numBytes / 4);
        const dataView = new DataView(keyBytes.buffer, keyBytes.byteOffset);

        for (let i = 0; i < numBlocks; i++) {
            const blockOffset = i * 4;
            let k1 = dataView.getUint32(blockOffset, true);

            k1 = Math.imul(k1, 0xcc9e2d51);
            k1 = (k1 << 15) | (k1 >>> 17);
            k1 = Math.imul(k1, 0x1b873593);

            currentHash ^= k1;
            currentHash = (currentHash << 13) | (currentHash >>> 19);
            currentHash = Math.imul(currentHash, 5) + 0xe6546b64;
            currentHash >>>= 0;
        }

        let k1 = 0;
        const tailIndex = numBlocks * 4;
        switch (numBytes & 3) {
            case 3:
                k1 ^= keyBytes[tailIndex + 2] << 16;
            // fallthrough
            case 2:
                k1 ^= keyBytes[tailIndex + 1] << 8;
            // fallthrough
            case 1:
                k1 ^= keyBytes[tailIndex];
                k1 = Math.imul(k1, 0xcc9e2d51);
                k1 = (k1 << 15) | (k1 >>> 17);
                k1 = Math.imul(k1, 0x1b873593);
                currentHash ^= k1;
        }

        currentHash ^= numBytes;
        currentHash ^= currentHash >>> 16;
        currentHash = Math.imul(currentHash, 0x85ebca6b);
        currentHash ^= currentHash >>> 13;
        currentHash = Math.imul(currentHash, 0xc2b2ae35);
        currentHash ^= currentHash >>> 16;

        return currentHash >>> 0;
    }

    let state = {
        isInitialized: false,
        isRunning: false,
        intervalId: null,
        attempts: 0,
        foundCount: 0,
        discordModules: {
            deleteGuild: null,
            createGuildFromTemplate: null,
        }
    };

    /**
     * Initializes necessary Discord modules using `findByProps`.
     * This is a critical step and relies on an external `findByProps` function.
     * @returns {boolean} True if initialization was successful, false otherwise.
     */
    function _initializeDiscordModules() {
        if (typeof findByProps !== 'function') {
            Logger.error("FATAL: `findByProps` function is not defined in the current environment.");
            Logger.warn("This script requires `findByProps` to locate Discord's internal modules.");
            Logger.warn("Ensure you are running this in an environment where it's available (e.g., Discord client console with developer tools/mods).");
            return false;
        }

        try {
            const guildManagerModule = findByProps("deleteGuild", "bulkAddMemberRoles");
            if (!guildManagerModule || typeof guildManagerModule.deleteGuild !== 'function') {
                Logger.error("Failed to find 'deleteGuild' function. Discord's internal structure might have changed.");
                return false;
            }
            state.discordModules.deleteGuild = guildManagerModule.deleteGuild;

            const templateManagerModule = findByProps("createGuildFromTemplate");
            if (!templateManagerModule || typeof templateManagerModule.createGuildFromTemplate !== 'function') {
                Logger.error("Failed to find 'createGuildFromTemplate' function. Discord's internal structure might have changed.");
                return false;
            }
            state.discordModules.createGuildFromTemplate = templateManagerModule.createGuildFromTemplate;

            Logger.success("Successfully initialized required Discord functions.");
            return true;
        } catch (err) {
            Logger.error("Fatal Error during Discord module initialization:", err.message);
            Logger.debug("Initialization error object:", err);
            return false;
        }
    }

    /**
     * Checks if the calculated hash falls within any of the defined target ranges.
     * @param {number} hash The hash to check.
     * @returns {boolean} True if the hash is in a target range, false otherwise.
     */
    function _checkHashCondition(hash) {
        return CONFIG.TARGET_HASH_RANGES.some(range => hash >= range.min && hash <= range.max);
    }

    /**
     * Schedules a guild for deletion after a specified delay.
     * @param {object} guild The guild object to delete.
     * @param {string} guild.id The ID of the guild.
     * @param {string} guild.name The name of the guild.
     */
    function _scheduleGuildDeletion(guild) {
        Logger.info(`Scheduling deletion for guild: ${guild.name} (ID: ${guild.id}) in ${CONFIG.DELETE_DELAY_MS / 1000}s.`);
        setTimeout(async () => {
            try {
                Logger.info(`Attempting to delete guild: ${guild.name} (ID: ${guild.id})...`);
                await state.discordModules.deleteGuild(guild.id);
                Logger.success(`Guild (ID: ${guild.id}) deleted successfully.`);
            } catch (deleteError) {
                Logger.error(`Failed to delete guild (ID: ${guild.id}). Error:`, deleteError.message);
                Logger.debug("Delete error details:", deleteError);
            }
        }, CONFIG.DELETE_DELAY_MS);
    }

    /**
     * Core logic for a single attempt: creates a guild, checks its hash, and handles it.
     */
    async function _createAndProcessGuild() {
        if (!state.isRunning) return;

        state.attempts++;
        const currentServerName = `${CONFIG.SERVER_NAME_PREFIX}${state.attempts}`;
        Logger.info(`Attempt #${state.attempts}: Trying to create guild "${currentServerName}"...`);

        try {
            const newGuild = await state.discordModules.createGuildFromTemplate(
                currentServerName,
                null,
                CONFIG.GUILD_TEMPLATE,
                false,
                false
            );

            if (!newGuild || !newGuild.id) {
                Logger.warn(`Attempt #${state.attempts}: Failed to create guild or API response was invalid.`, newGuild || "No response object");
                return;
            }

            Logger.info(`Attempt #${state.attempts}: Guild created: ${newGuild.name} (ID: ${newGuild.id})`);

            const hashInputString = `${CONFIG.HASH_SALT_PREFIX}${newGuild.id}`;
            const calculatedHash = murmurhash3_32_gc(hashInputString) % CONFIG.HASH_MODULO;

            Logger.debug(`Attempt #${state.attempts}: Hash input: "${hashInputString}", Calculated hash (mod ${CONFIG.HASH_MODULO}): ${calculatedHash}`);

            if (_checkHashCondition(calculatedHash)) {
                state.foundCount++;
                Logger.success(`TARGET GUILD FOUND! (Total Found: ${state.foundCount}) 🎉`);
                Logger.success(`  Guild Name: ${newGuild.name}`);
                Logger.success(`  Guild ID: ${newGuild.id}`);
                Logger.success(`  Calculated Hash: ${calculatedHash} (Target Ranges: ${JSON.stringify(CONFIG.TARGET_HASH_RANGES)})`);
                Logger.info("This guild will NOT be deleted. Script continues searching.");
            } else {
                Logger.info(`Attempt #${state.attempts}: Guild (ID: ${newGuild.id}) hash ${calculatedHash} is not in target range.`);
                _scheduleGuildDeletion(newGuild);
            }

        } catch (error) {
            Logger.error(`Attempt #${state.attempts}: An error occurred during guild creation or processing:`, error.message);
            Logger.debug("Creation/Processing error object:", error);

            const errorMessageLower = (error.message || "").toLowerCase();
            const errorBodyMessageLower = (error.body && error.body.message || "").toLowerCase();
            if (errorMessageLower.includes("rate limit") || errorBodyMessageLower.includes("rate limit") || (error.status === 429)) {
                Logger.warn("RATE LIMIT DETECTED. The script may be operating too fast.");
                Logger.warn(`Consider increasing CONFIG.ATTEMPT_INTERVAL_MS (current: ${CONFIG.ATTEMPT_INTERVAL_MS}ms).`);
                Logger.warn("Pausing for a moment before next attempt might be needed if this persists.");
            }
        }
    }

    /**
     * Starts the guild creation and checking process.
     * Will not start if already running or if essential modules are not initialized.
     */
    function start() {
        if (!state.isInitialized) {
            Logger.error("Script not initialized. Call `GuildTagFinder.initialize()` first or ensure `findByProps` is available.");
            return;
        }
        if (state.isRunning) {
            Logger.warn("Script is already running.");
            return;
        }

        state.isRunning = true;
        Logger.info(`Script Version ${CONFIG.SCRIPT_VERSION} starting...`);
        Logger.info(`Guild Creation Interval: ${CONFIG.ATTEMPT_INTERVAL_MS / 1000}s`);
        Logger.info(`Post-creation Delete Delay (for non-target guilds): ${CONFIG.DELETE_DELAY_MS / 1000}s`);
        const hashRangesString = CONFIG.TARGET_HASH_RANGES.map(r => `${r.min}-${r.max}`).join(' & ');
        Logger.info(`Searching for guilds where (hash('${CONFIG.HASH_SALT_PREFIX}' + GuildID) % ${CONFIG.HASH_MODULO}) is in ranges: [${hashRangesString}].`);
        Logger.info(`To stop the script, execute: GuildTagFinder.stop()`);
        Logger.warn("REMINDER: Use this script responsibly. Excessive API calls can lead to rate-limiting or other account actions by Discord.");

        _createAndProcessGuild();
        state.intervalId = setInterval(_createAndProcessGuild, CONFIG.ATTEMPT_INTERVAL_MS);
    }

    /**
     * Stops the guild creation and checking process.
     * Clears the interval and logs a summary.
     */
    function stop() {
        if (!state.isRunning) {
            Logger.warn("Script is not currently running or was already stopped.");
            return;
        }
        if (state.intervalId !== null) {
            clearInterval(state.intervalId);
            state.intervalId = null;
        }
        state.isRunning = false;
        Logger.info("Script stopped. Guild creation interval cleared.");
        Logger.info(`Summary: Total attempts: ${state.attempts}, Target guilds found: ${state.foundCount}`);
    }

    /**
     * Initializes the script by trying to locate necessary Discord modules.
     * This should be called once before `start()`.
     * @returns {boolean} True if initialization was successful, false otherwise.
     */
    function initialize() {
        if (state.isInitialized) {
            Logger.info("Script already initialized.");
            return true;
        }
        Logger.info("Initializing GuildTagFinder...");
        if (_initializeDiscordModules()) {
            state.isInitialized = true;
            Logger.success("GuildTagFinder initialized successfully. Ready to start.");
            Logger.info("Call GuildTagFinder.start() to begin.");
            return true;
        } else {
            Logger.error("GuildTagFinder initialization failed. Please check console errors for details.");
            Logger.error("The script cannot run without successful initialization.");
            return false;
        }
    }

    Logger.info(`GuildTagFinder Script v${CONFIG.SCRIPT_VERSION} loaded.`);
    Logger.warn("This script interacts with Discord's API. Use responsibly.");
    Logger.info("Run `GuildTagFinder.initialize()` first, then `GuildTagFinder.start()` to begin.");


    return {
        initialize,
        start,
        stop,
        getConfig: () => JSON.parse(JSON.stringify(CONFIG)),
        setDebugMode: (enabled) => {
            CONFIG.LOGGER_OPTIONS.DEBUG_MODE = !!enabled;
            Logger.info(`Debug mode ${enabled ? 'enabled' : 'disabled'}.`);
        }
    };
})();
	/**
	* @file discord-guild-tag-finder.js
	* @version 1.2.5
	* @description Automates the creation and checking of Discord guilds to find ones with specific ID-based hash characteristics.
	* @author Revere Development
	*
	* @warning This script interacts with the Discord API in ways that might be considered
	* abusive if not used responsibly. Excessive use can lead to rate-limiting,
	* account suspension, or other actions by Discord. Use at your own risk and
	* be mindful of the Discord Terms of Service and API usage guidelines.
	* This script is intended for educational and research purposes.
	*
	* @dependency This script relies on a `findByProps` function being available in its
	* execution environment (e.g., Discord client console with developer tools
	* enhanced by a client mod like Vencord, BetterDiscord, etc.).
	* If `findByProps` is not found, the script will not initialize.
	*/

	const GuildTagFinder = (() => {
	'use strict';

	const CONFIG = {
	SCRIPT_VERSION: "1.2.5",
	ATTEMPT_INTERVAL_MS: 65 * 1000,
	DELETE_DELAY_MS: 3 * 1000,
	SERVER_NAME_PREFIX: "TagFinder Server #",
	HASH_SALT_PREFIX: "2025-02_skill_trees:",
	HASH_MODULO: 10000,
	TARGET_HASH_RANGES: [
	{ min: 10, max: 19 },
	{ min: 60, max: 99 },
	{ min: 150, max: 199 },
	{ min: 600, max: 999 },
	{ min: 1500, max: 1999 },
	{ min: 2250, max: 2499 },
	{ min: 2750, max: 2999 },
	],
	GUILD_TEMPLATE: {
	id: "CREATE",
	label: "Create My Own",
	channels: [],
	system_channel_id: null,
	},
	LOGGER_OPTIONS: {
	USE_TIMESTAMPS: false,
	DEBUG_MODE: false,
	}
	};

	const Logger = {
	_log: (level, color, ...messages) => {
	const prefix = CONFIG.LOGGER_OPTIONS.USE_TIMESTAMPS ?
	`[${new Date().toISOString()}] [${level}]` :
	`[${level}]`;
	console.log(`%c${prefix}`, `color: ${color}; font-weight: bold;`, ...messages);
	},
	info: (...messages) => Logger._log('INFO', 'dodgerblue', ...messages),
	success: (...messages) => Logger._log('SUCCESS', 'green', ...messages),
	warn: (...messages) => Logger._log('WARN', 'orange', ...messages),
	error: (...messages) => Logger._log('ERROR', 'red', ...messages),
	debug: (...messages) => {
	if (CONFIG.LOGGER_OPTIONS.DEBUG_MODE) {
	Logger._log('DEBUG', 'purple', ...messages);
	}
	},
	};

	/**
	* Calculates a 32-bit MurmurHash3.
	* This is a common non-cryptographic hashing algorithm.
	* @param {string} key The string to hash.
	* @param {number} [seed=0] An optional seed.
	* @returns {number} The 32-bit hash, unsigned.
	*/
	function murmurhash3_32_gc(key, seed = 0) {
	let currentHash = seed;
	const textEncoder = new TextEncoder();
	const keyBytes = textEncoder.encode(key);
	const numBytes = keyBytes.length;
	const numBlocks = Math.floor(numBytes / 4);
	const dataView = new DataView(keyBytes.buffer, keyBytes.byteOffset);

	for (let i = 0; i < numBlocks; i++) {
	const blockOffset = i * 4;
	let k1 = dataView.getUint32(blockOffset, true);

	k1 = Math.imul(k1, 0xcc9e2d51);
	k1 = (k1 << 15) \| (k1 >>> 17);
	k1 = Math.imul(k1, 0x1b873593);

	currentHash ^= k1;
	currentHash = (currentHash << 13) \| (currentHash >>> 19);
	currentHash = Math.imul(currentHash, 5) + 0xe6546b64;
	currentHash >>>= 0;
	}

	let k1 = 0;
	const tailIndex = numBlocks * 4;
	switch (numBytes & 3) {
	case 3:
	k1 ^= keyBytes[tailIndex + 2] << 16;
	// fallthrough
	case 2:
	k1 ^= keyBytes[tailIndex + 1] << 8;
	// fallthrough
	case 1:
	k1 ^= keyBytes[tailIndex];
	k1 = Math.imul(k1, 0xcc9e2d51);
	k1 = (k1 << 15) \| (k1 >>> 17);
	k1 = Math.imul(k1, 0x1b873593);
	currentHash ^= k1;
	}

	currentHash ^= numBytes;
	currentHash ^= currentHash >>> 16;
	currentHash = Math.imul(currentHash, 0x85ebca6b);
	currentHash ^= currentHash >>> 13;
	currentHash = Math.imul(currentHash, 0xc2b2ae35);
	currentHash ^= currentHash >>> 16;

	return currentHash >>> 0;
	}

	let state = {
	isInitialized: false,
	isRunning: false,
	intervalId: null,
	attempts: 0,
	foundCount: 0,
	discordModules: {
	deleteGuild: null,
	createGuildFromTemplate: null,
	}
	};

	/**
	* Initializes necessary Discord modules using `findByProps`.
	* This is a critical step and relies on an external `findByProps` function.
	* @returns {boolean} True if initialization was successful, false otherwise.
	*/
	function _initializeDiscordModules() {
	if (typeof findByProps !== 'function') {
	Logger.error("FATAL: `findByProps` function is not defined in the current environment.");
	Logger.warn("This script requires `findByProps` to locate Discord's internal modules.");
	Logger.warn("Ensure you are running this in an environment where it's available (e.g., Discord client console with developer tools/mods).");
	return false;
	}

	try {
	const guildManagerModule = findByProps("deleteGuild", "bulkAddMemberRoles");
	if (!guildManagerModule \|\| typeof guildManagerModule.deleteGuild !== 'function') {
	Logger.error("Failed to find 'deleteGuild' function. Discord's internal structure might have changed.");
	return false;
	}
	state.discordModules.deleteGuild = guildManagerModule.deleteGuild;

	const templateManagerModule = findByProps("createGuildFromTemplate");
	if (!templateManagerModule \|\| typeof templateManagerModule.createGuildFromTemplate !== 'function') {
	Logger.error("Failed to find 'createGuildFromTemplate' function. Discord's internal structure might have changed.");
	return false;
	}
	state.discordModules.createGuildFromTemplate = templateManagerModule.createGuildFromTemplate;

	Logger.success("Successfully initialized required Discord functions.");
	return true;
	} catch (err) {
	Logger.error("Fatal Error during Discord module initialization:", err.message);
	Logger.debug("Initialization error object:", err);
	return false;
	}
	}

	/**
	* Checks if the calculated hash falls within any of the defined target ranges.
	* @param {number} hash The hash to check.
	* @returns {boolean} True if the hash is in a target range, false otherwise.
	*/
	function _checkHashCondition(hash) {
	return CONFIG.TARGET_HASH_RANGES.some(range => hash >= range.min && hash <= range.max);
	}

	/**
	* Schedules a guild for deletion after a specified delay.
	* @param {object} guild The guild object to delete.
	* @param {string} guild.id The ID of the guild.
	* @param {string} guild.name The name of the guild.
	*/
	function _scheduleGuildDeletion(guild) {
	Logger.info(`Scheduling deletion for guild: ${guild.name} (ID: ${guild.id}) in ${CONFIG.DELETE_DELAY_MS / 1000}s.`);
	setTimeout(async () => {
	try {
	Logger.info(`Attempting to delete guild: ${guild.name} (ID: ${guild.id})...`);
	await state.discordModules.deleteGuild(guild.id);
	Logger.success(`Guild (ID: ${guild.id}) deleted successfully.`);
	} catch (deleteError) {
	Logger.error(`Failed to delete guild (ID: ${guild.id}). Error:`, deleteError.message);
	Logger.debug("Delete error details:", deleteError);
	}
	}, CONFIG.DELETE_DELAY_MS);
	}

	/**
	* Core logic for a single attempt: creates a guild, checks its hash, and handles it.
	*/
	async function _createAndProcessGuild() {
	if (!state.isRunning) return;

	state.attempts++;
	const currentServerName = `${CONFIG.SERVER_NAME_PREFIX}${state.attempts}`;
	Logger.info(`Attempt #${state.attempts}: Trying to create guild "${currentServerName}"...`);

	try {
	const newGuild = await state.discordModules.createGuildFromTemplate(
	currentServerName,
	null,
	CONFIG.GUILD_TEMPLATE,
	false,
	false
	);

	if (!newGuild \|\| !newGuild.id) {
	Logger.warn(`Attempt #${state.attempts}: Failed to create guild or API response was invalid.`, newGuild \|\| "No response object");
	return;
	}

	Logger.info(`Attempt #${state.attempts}: Guild created: ${newGuild.name} (ID: ${newGuild.id})`);

	const hashInputString = `${CONFIG.HASH_SALT_PREFIX}${newGuild.id}`;
	const calculatedHash = murmurhash3_32_gc(hashInputString) % CONFIG.HASH_MODULO;

	Logger.debug(`Attempt #${state.attempts}: Hash input: "${hashInputString}", Calculated hash (mod ${CONFIG.HASH_MODULO}): ${calculatedHash}`);

	if (_checkHashCondition(calculatedHash)) {
	state.foundCount++;
	Logger.success(`TARGET GUILD FOUND! (Total Found: ${state.foundCount}) 🎉`);
	Logger.success(` Guild Name: ${newGuild.name}`);
	Logger.success(` Guild ID: ${newGuild.id}`);
	Logger.success(` Calculated Hash: ${calculatedHash} (Target Ranges: ${JSON.stringify(CONFIG.TARGET_HASH_RANGES)})`);
	Logger.info("This guild will NOT be deleted. Script continues searching.");
	} else {
	Logger.info(`Attempt #${state.attempts}: Guild (ID: ${newGuild.id}) hash ${calculatedHash} is not in target range.`);
	_scheduleGuildDeletion(newGuild);
	}

	} catch (error) {
	Logger.error(`Attempt #${state.attempts}: An error occurred during guild creation or processing:`, error.message);
	Logger.debug("Creation/Processing error object:", error);

	const errorMessageLower = (error.message \|\| "").toLowerCase();
	const errorBodyMessageLower = (error.body && error.body.message \|\| "").toLowerCase();
	if (errorMessageLower.includes("rate limit") \|\| errorBodyMessageLower.includes("rate limit") \|\| (error.status === 429)) {
	Logger.warn("RATE LIMIT DETECTED. The script may be operating too fast.");
	Logger.warn(`Consider increasing CONFIG.ATTEMPT_INTERVAL_MS (current: ${CONFIG.ATTEMPT_INTERVAL_MS}ms).`);
	Logger.warn("Pausing for a moment before next attempt might be needed if this persists.");
	}
	}
	}

	/**
	* Starts the guild creation and checking process.
	* Will not start if already running or if essential modules are not initialized.
	*/
	function start() {
	if (!state.isInitialized) {
	Logger.error("Script not initialized. Call `GuildTagFinder.initialize()` first or ensure `findByProps` is available.");
	return;
	}
	if (state.isRunning) {
	Logger.warn("Script is already running.");
	return;
	}

	state.isRunning = true;
	Logger.info(`Script Version ${CONFIG.SCRIPT_VERSION} starting...`);
	Logger.info(`Guild Creation Interval: ${CONFIG.ATTEMPT_INTERVAL_MS / 1000}s`);
	Logger.info(`Post-creation Delete Delay (for non-target guilds): ${CONFIG.DELETE_DELAY_MS / 1000}s`);
	const hashRangesString = CONFIG.TARGET_HASH_RANGES.map(r => `${r.min}-${r.max}`).join(' & ');
	Logger.info(`Searching for guilds where (hash('${CONFIG.HASH_SALT_PREFIX}' + GuildID) % ${CONFIG.HASH_MODULO}) is in ranges: [${hashRangesString}].`);
	Logger.info(`To stop the script, execute: GuildTagFinder.stop()`);
	Logger.warn("REMINDER: Use this script responsibly. Excessive API calls can lead to rate-limiting or other account actions by Discord.");

	_createAndProcessGuild();
	state.intervalId = setInterval(_createAndProcessGuild, CONFIG.ATTEMPT_INTERVAL_MS);
	}

	/**
	* Stops the guild creation and checking process.
	* Clears the interval and logs a summary.
	*/
	function stop() {
	if (!state.isRunning) {
	Logger.warn("Script is not currently running or was already stopped.");
	return;
	}
	if (state.intervalId !== null) {
	clearInterval(state.intervalId);
	state.intervalId = null;
	}
	state.isRunning = false;
	Logger.info("Script stopped. Guild creation interval cleared.");
	Logger.info(`Summary: Total attempts: ${state.attempts}, Target guilds found: ${state.foundCount}`);
	}

	/**
	* Initializes the script by trying to locate necessary Discord modules.
	* This should be called once before `start()`.
	* @returns {boolean} True if initialization was successful, false otherwise.
	*/
	function initialize() {
	if (state.isInitialized) {
	Logger.info("Script already initialized.");
	return true;
	}
	Logger.info("Initializing GuildTagFinder...");
	if (_initializeDiscordModules()) {
	state.isInitialized = true;
	Logger.success("GuildTagFinder initialized successfully. Ready to start.");
	Logger.info("Call GuildTagFinder.start() to begin.");
	return true;
	} else {
	Logger.error("GuildTagFinder initialization failed. Please check console errors for details.");
	Logger.error("The script cannot run without successful initialization.");
	return false;
	}
	}

	Logger.info(`GuildTagFinder Script v${CONFIG.SCRIPT_VERSION} loaded.`);
	Logger.warn("This script interacts with Discord's API. Use responsibly.");
	Logger.info("Run `GuildTagFinder.initialize()` first, then `GuildTagFinder.start()` to begin.");


	return {
	initialize,
	start,
	stop,
	getConfig: () => JSON.parse(JSON.stringify(CONFIG)),
	setDebugMode: (enabled) => {
	CONFIG.LOGGER_OPTIONS.DEBUG_MODE = !!enabled;
	Logger.info(`Debug mode ${enabled ? 'enabled' : 'disabled'}.`);
	}
	};
	})();