#include 
#include  // 包含 rand() 和 srand()
#include  // 包含 LLONG_MIN
#include  // 包含 memset
// 定义迷宫尺寸
#define MAX_COL 50 // 最大列号
#define MAX_ROW 50 // 最大行号 (根据生成代码 j <= i <= 50，最大行号不会超过 50)
// 存储迷宫得分值的二维数组
// 使用 MAX_COL+1 和 MAX_ROW+1 大小，方便使用 1-based 索引 [1..50][1..50]
int maze_values[MAX_COL + 1][MAX_ROW + 1];
// 动态规划表：dp[c][r] 存储到达 (列 c, 行 r) 的最大累积得分 (不含初始值)
// 使用 long long 防止得分溢出
long long dp[MAX_COL + 1][MAX_ROW + 1];
// 父移动记录表：parent_move[c][r] 存储到达 (列 c, 行 r) 所需的前一步移动 ('A', 'B', 'C')
char parent_move[MAX_COL + 1][MAX_ROW + 1];
int main() {
	// 1. 生成迷宫得分数据
	// 使用与 C++ 代码相同的种子
	srand(0x3CAC);
	// 按照生成代码的逻辑填充 maze_values 数组
	for (int i = 1; i <= MAX_COL; ++i) { // 列从 1 到 50
		for (int j = 1; j <= i; ++j) { // 行从 1 到 当前列号 i
			maze_values[i][j] = rand() % 19492025;
		}
	}
	// 2. 初始化动态规划表
	// 将 dp 表所有值初始化为一个很小的数，表示不可达
	// memset(dp, 0x80, sizeof(dp)); // 一种快速填充 LLONG_MIN 的方法，依赖于 LLONG_MIN 的表示
	// 或者使用循环初始化，更安全可靠
	for (int i = 0; i <= MAX_COL; ++i) {
		for (int j = 0; j <= MAX_ROW; ++j) {
			dp[i][j] = LLONG_MIN;
			parent_move[i][j] = '\0'; // 初始化移动记录
		}
	}
	// 3. Base cases: 从 (1,1) 移动到第 2 列
	int start_row = 1;
	int c2 = 2; // 第一步到达第 2 列
	// 从 (1,1) 移动 'B' 到 (2,2)
	int r2_B = start_row + 1; // 新行号 2
	int prev_r_B = start_row; // 前一行号 1
	// 检查前一位置 (c2-1, prev_r_B) 即 (1, 1) 是否在生成范围内 (1 <= prev_r <= c-1) 且当前位置 (c2, r2_B) 行号有效 (>= 1) 且在生成范围内 (1 <= r <= c)
	if (prev_r_B >= 1 && prev_r_B <= c2 - 1 && r2_B >= 1 && r2_B <= c2) {
		dp[c2][r2_B] = maze_values[c2][r2_B];
		parent_move[c2][r2_B] = 'B';
	}
	// 从 (1,1) 移动 'C' 到 (2,1)
	int r2_C = start_row; // 新行号 1
	int prev_r_C = start_row; // 前一行号 1
	// 检查前一位置 (c2-1, prev_r_C) 即 (1, 1) 是否在生成范围内 (1 <= prev_r <= c-1) 且当前位置 (c2, r2_C) 行号有效 (>= 1) 且在生成范围内 (1 <= r <= c)
	if (prev_r_C >= 1 && prev_r_C <= c2 - 1 && r2_C >= 1 && r2_C <= c2) {
		// 对于第一列，只有一种方式到达某个有效格子，直接赋值即可
		dp[c2][r2_C] = maze_values[c2][r2_C];
		parent_move[c2][r2_C] = 'C';
	}
	// 从 (1,1) 移动 'A' 到 (2,0)，行号 0 无效，不处理
	// 4. 动态规划转移
	// 从第 3 列开始，到第 50 列
	for (int c = 3; c <= MAX_COL; ++c) {
		// 在列 c，行号 r 可能从 1 到 c (根据生成范围 1<=j<=i 和行走时行号的变化推断)
		for (int r = 1; r <= c; ++r) {
			// 如果当前位置 (c, r) 在迷宫数据生成范围内 (1 <= r <= c)
			// 注意：根据生成代码，只有这个范围内有非零值，其他位置可能为 0 或其他初始值
			// 伪代码直接使用了索引，我们假设未生成的位置得分是 0 或者 DP 不会通过这些位置过来
			// 这里假设我们只关心生成范围内的分数，或者未生成的位置分数是 0
			// 如果未生成位置得分是 0，当前格子得分 current_val 就是 maze_values[c][r]
			// 如果是 0，则需要在生成时确保这些位置初始化为 0
			// 我们的 maze_values 初始化为 0 了，但 DP 状态 LLONG_MIN 处理了不可达
			int current_val = maze_values[c][r]; // 当前格子 (c, r) 的得分值
			// 考虑从前一列 c-1 如何到达当前位置 (c, r)
			// 1. 通过 'A' 移动到达 (c, r)
			// 前一位置是 (c-1, r+1)
			int prev_r_A = r + 1;
			// 检查前一位置 (c-1, prev_r_A) 的行号是否有效 (>= 1) 且在前一列 c-1 的生成范围内 (<= c-1)
			if (prev_r_A >= 1 && prev_r_A <= c - 1) {
				// 检查前一位置 (c-1, prev_r_A) 是否可达 (DP 值不是初始的 LLONG_MIN)
				if (dp[c-1][prev_r_A] != LLONG_MIN) {
					long long potential_score = dp[c-1][prev_r_A] + current_val;
					// 检查当前位置 (c, r) 的行号是否有效 (>= 1) - r 从 1 开始，总是满足
					if (potential_score > dp[c][r]) {
						dp[c][r] = potential_score;
						parent_move[c][r] = 'A';
					}
				}
			}
			// 2. 通过 'B' 移动到达 (c, r)
			// 前一位置是 (c-1, r-1)
			int prev_r_B = r - 1;
			// 检查前一位置 (c-1, prev_r_B) 的行号是否有效 (>= 1) 且在前一列 c-1 的生成范围内 (<= c-1)
			if (prev_r_B >= 1 && prev_r_B <= c - 1) {
				// 检查前一位置是否可达
				if (dp[c-1][prev_r_B] != LLONG_MIN) {
					long long potential_score = dp[c-1][prev_r_B] + current_val;
					// 检查当前位置 (c, r) 的行号是否有效 (>= 1)
					if (potential_score > dp[c][r]) {
						dp[c][r] = potential_score;
						parent_move[c][r] = 'B';
					}
				}
			}
			// 3. 通过 'C' 移动到达 (c, r)
			// 前一位置是 (c-1, r)
			int prev_r_C = r;
			// 检查前一位置 (c-1, prev_r_C) 的行号是否有效 (>= 1) 且在前一列 c-1 的生成范围内 (<= c-1)
			if (prev_r_C >= 1 && prev_r_C <= c - 1) {
				// 检查前一位置是否可达
				if (dp[c-1][prev_r_C] != LLONG_MIN) {
					long long potential_score = dp[c-1][prev_r_C] + current_val;
					// 检查当前位置 (c, r) 的行号是否有效 (>= 1)
					if (potential_score > dp[c][r]) {
						dp[c][r] = potential_score;
						parent_move[c][r] = 'C';
					}
				}
			}
		}
	}
	// 5. 找到第 50 列 (MAX_COL) 的最大得分和对应的结束行号
	long long max_score = LLONG_MIN;
	int end_row = -1;
	for (int r = 1; r <= MAX_ROW; ++r) { // 在第 50 列，可能的行号从 1 到 50
		if (dp[MAX_COL][r] != LLONG_MIN && dp[MAX_COL][r] > max_score) {
			max_score = dp[MAX_COL][r];
			end_row = r;
		}
	}
	// 检查是否找到了有效的路径终点
	if (end_row == -1) {
		printf("错误：无法到达迷宫的终点 (第 %d 列)。\n", MAX_COL);
		return 1;
	}
	// 6. 回溯路径
	char path[MAX_COL]; // 路径长度是 49 步 (从列 2 到列 50)
	int path_index = MAX_COL - 2; // 路径数组索引从 0 到 48，从后往前填充
	int current_c = MAX_COL; // 从终点列开始回溯
	int current_r = end_row; // 从终点行开始回溯
	// 回溯 49 步，从第 50 列回到第 2 列
	while (current_c > 1) {
		char move = parent_move[current_c][current_r];
		path[path_index--] = move; // 将当前步的移动加到路径前面
		// 根据移动反向计算前一步的行号
		if (move == 'A') {
			current_r += 1; // 如果当前位置是通过 'A' (上移) 到达的，那么前一步在当前行的下一行
		} else if (move == 'B') {
			current_r -= 1; // 如果当前位置是通过 'B' (下移) 到达的，那么前一步在当前行的上一行
		}
		// 如果 move 是 'C' (不动)，则前一步在同一行 (current_r 不变)
		current_c -= 1; // 回溯到前一列
	}
	path[MAX_COL - 1] = '\0'; // 路径字符串以 null 终止
	// 7. 输出结果
	printf("最大累积迷宫得分 (不含初始值): %lld\n", max_score);
	printf("最优路径 (Flag 内容): %s\n", path);
	printf("路径长度: %zu\n", strlen(path)); // 验证路径长度是否为 49
	return 0;
}

import init from './WoAiShiinaMahiru.js';
async function main() {
    const wasm = await init();
    const { check_flag, alloc, memory } = wasm;
    function readWasmMemory(offset, length) {
        const memview = new Uint8Array(memory.buffer);
        // 使用 slice 创建一个副本，避免原始 buffer 被意外修改影响结果
        const data = memview.slice(offset, offset + length);
        return data;
    }
    async function attemptFlag(flag) {
        const encoded = new TextEncoder().encode(flag);
        const ptr = alloc(encoded.length);
        new Uint8Array(memory.buffer, ptr, encoded.length).set(encoded);
        // 调用 check_flag，注意：这里我们没有使用它的返回值，假设逻辑依赖于内存比较
        check_flag(ptr, encoded.length); // 忽略返回值 result
        // 定义偏移量和长度 (与原代码保持一致)
        const encryptedOffset = ptr + 0x30;
        const compareOffset = ptr + 0x60;
        const length = 44; // 假设 flag 长度和比较长度都是 44
        // 从 WASM 内存读取数据
        // !! 注意：读取操作应该在 check_flag 执行后进行
        const encryptedData = readWasmMemory(encryptedOffset, length);
        const compareData = readWasmMemory(compareOffset, length);
        // 注意：WASM 的内存管理，理论上 alloc 的内存在使用后可能需要 dealloc，
        // 但在这个爆破场景下，每次调用 alloc 可能问题不大，除非内存泄漏严重。
        // 如果 WASM 提供了 free/dealloc 函数，最好在读取完数据后调用。
        // 返回读取到的数据，注意原代码返回的 result 被忽略了
        return { encryptedData, compareData };
    }
    async function bruteForceFlag() {
        const flagLength = 44; // 假设 flag 长度为 44
        let currentFlag = "";
        // 确保字符集包含 flag 可能的所有字符
        const possibleChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_{}-"; // 扩展字符集以防万一
        document.getElementById("result").textContent = "开始自动爆破...";
        for (let i = 0; i < flagLength; i++) {
            let foundChar = null;
            for (const char of possibleChars) {
                // 构造测试 flag: 当前已知部分 + 测试字符 + 填充 (使用 'A' 或其他字符)
                const testFlag = currentFlag + char + "A".repeat(flagLength - currentFlag.length - 1);
                const { encryptedData, compareData } = await attemptFlag(testFlag);
                // --- 修改后的比较逻辑 ---
                let match = true;
                // 只比较到当前尝试的字符位置 i (包含 i)
                // 同时检查索引是否越界
                if (i < encryptedData.length && i < compareData.length) {
                    for (let j = 0; j <= i; j++) {
                        if (encryptedData[j] !== compareData[j]) {
                            match = false;
                            break;
                        }
                    }
                } else {
                    console.error(`错误：尝试比较的索引 ${i} 超出了获取数据的长度 (${encryptedData.length}, ${compareData.length})`);
                    match = false; // 无法比较，认为不匹配
                }
                // --- 比较逻辑结束 ---
                if (match) {
                    currentFlag += char;
                    foundChar = char;
                    console.log(`找到第 ${i + 1} 位: ${char}, 当前 Flag: ${currentFlag}`);
                    document.getElementById("result").textContent = `正在爆破... (${currentFlag.length}/${flagLength}) ${currentFlag}`;
                    break; // 找到当前位置的字符，跳出内层循环
                }
            } // 内层循环结束 (尝试所有字符)
            if (!foundChar) {
                console.log(`爆破失败，在位置 ${i} 无法找到匹配的字符。`);
                document.getElementById("result").textContent = `❌ 爆破失败，在位置 ${i} 无法找到匹配字符。当前进度: ${currentFlag}`;
                return; // 终止爆破
            }
        } // 外层循环结束 (遍历所有位置)
        if (currentFlag.length === flagLength) {
            console.log("🎉 爆破成功！Flag 为:", currentFlag);
            // 最后用完整的 flag 验证一次 (可选，但建议)
            const finalAttempt = await attemptFlag(currentFlag);
            let finalMatch = true;
            if (flagLength <= finalAttempt.encryptedData.length && flagLength <= finalAttempt.compareData.length) {
                 for (let j = 0; j < flagLength; j++) {
                    if (finalAttempt.encryptedData[j] !== finalAttempt.compareData[j]) {
                        finalMatch = false;
                        break;
                    }
                 }
            } else {
                finalMatch = false; // 长度不足
            }
            if (finalMatch) {
                 document.getElementById("result").textContent = `🎉 爆破成功！Flag 为: ${currentFlag}`;
            } else {
                 document.getElementById("result").textContent = `🤔 爆破完成，但最终验证失败？Flag 可能为: ${currentFlag}`;
                 console.warn("爆破声称成功，但最终验证时内存比较不完全匹配。");
            }
        } else {
            // 理论上如果中间没有 return，这里不应该执行
            document.getElementById("result").textContent = "❌ 爆破未完成，但循环结束了？";
        }
    }
    document.getElementById("verifyButton").addEventListener("click", async () => {
        const verifyButton = document.getElementById("verifyButton");
        const resultDiv = document.getElementById("result"); // 获取显示结果的元素
        verifyButton.disabled = true;
        verifyButton.textContent = "爆破中...";
        resultDiv.textContent = "初始化 Wasm 并准备爆破..."; // 初始提示
        try {
            await bruteForceFlag(); // 执行爆破
        } catch (error) {
            console.error("爆破过程中发生错误:", error);
            resultDiv.textContent = `❌ 爆破过程中发生错误: ${error.message}`;
        } finally {
            // 无论成功、失败或出错，都重新启用按钮
            verifyButton.disabled = false;
            verifyButton.textContent = "开始验证";
        }
    });
}
// 调用 main 函数启动逻辑
main().catch(err => {
    console.error("初始化或执行 main 函数时出错:", err);
    // 可以在页面上显示错误信息
    const resultDiv = document.getElementById("result");
    if (resultDiv) {
        resultDiv.textContent = `❌ 初始化失败: ${err.message}`;
    }
});