Objetivo: obtener código fuente que compile un ejecutable idéntico byte a byte al gbr.exe instalado. El criterio de éxito es SHA-256 F8B9518FFE31CBBB1C2C4236426DB866295AC9BE4C13794537B999B05AA647F7 para un archivo de 4 456 448 bytes. El lanzador Inicio del juego.exe es otro ejecutable y no forma parte de esta reconstrucción por ahora.

Los ocho rangos de .text muestran el porcentaje de bytes clasificados como código por IDA que ya tienen una coincidencia exacta. Cada cuadradito corresponde a un rango de direcciones y su parte verde indica la fracción verificada. La cabecera PE, .rdata, .data, .tls y .rsrc también coinciden byte a byte. El mapa se regenera con python tools/generate_progress_image.py después de actualizar notes/coverage.json y notes/recovered_text_layout.json.

El porcentaje general cuenta únicamente bytes que IDA clasifica como código. Incluye funciones recompiladas y rangos conservados explícitamente como bytes de ensamblador; 100 % de coincidencia binaria no significa 100 % de descompilación a C/C++ de alto nivel. Algunos tramos de función incluyen datos intercalados; esos bytes se verifican igualmente, pero se informan por separado en notes/coverage.json.

Una revisión posterior encontró siete funciones SEH y otras 192 entradas de función que IDA no había incorporado al inventario. Sus fuentes reproducen 12 872 bytes exactos. Entre esas entradas, 159 accesores globales, un acceso al descriptor CVXItemScript, dos reconocedores de entidades XML, diez rutinas de aritmética y estado, cuatro funciones de validación UTF-8 y manejo de handles y dos métodos adicionales tienen fuentes C++ legibles. Las otras catorce entradas y las siete funciones SEH usan ensamblador integrado. Se corrigieron cuatro entradas de función falsas. Ver notes/hidden_seh.md, notes/hidden_entries.md, notes/global_accessors.md, notes/semantic_orphans.md, notes/utf8_handle_recovery.md y notes/member_methods.md. El contador histórico de 13 777 funciones se refiere a la instantánea inicial de IDA.

Se publican las fuentes reconstruidas y el pseudocódigo exportado en src/, las herramientas de compilación y verificación en tools/, los resultados y el diario en notes/, los borradores en experiments/ y la imagen de progreso en docs/. Los archivos originales del juego, la base privada de IDA, el compilador externo y los ejecutables generados permanecen fuera de Git; están en orig/, ida/, toolchain/ y build/ del entorno local. Para repetir las verificaciones que leen el ejecutable original se necesitan esos archivos localmente.

Los primeros puntos describen etapas históricas; la cobertura vigente se indica en la imagen, notes/coverage.json y notes/PROGRESO.md.

• orig/gbr.exe conserva una copia idéntica al archivo instalado.
• ida/gbr.exe.i64 contiene la base privada de IDA. La instantánea exportada en ida/ identifica 13 777 entradas de función, 8 936 cadenas, 3 667 056 bytes de código, 174 967 bytes de datos y 25 bytes sin clasificar dentro de .text; detecta 505 instrucciones de salto con tabla. Cuatro entradas de función eran falsas y la base privada guarda 197 funciones encontradas después de esa exportación. Las categorías de la instantánea no prueban que se haya recuperado todo el comportamiento.
• src/pseudocode/ contiene pseudocódigo de Hex-Rays para las 13 777 funciones de la instantánea exportada; todas terminaron sin error. Todavía no es código compilable ni prueba de equivalencia. El diario está en notes/pseudocode_export.jsonl.
• toolchain/vc71/ contiene el compilador y bibliotecas de Visual C++ Toolkit 2003. La cabecera PE indica enlazador 7.10, dato compatible con esa familia de herramientas, pero insuficiente para identificar todas las opciones originales.
• src/reconstructed/ contiene seis funciones reconstruidas a mano y 101 funciones simples generadas a partir de patrones de instrucciones. python tools/verify_matched_functions.py recompila cada una con VC++ 2003 /O2 y verifica coincidencia exacta de su código máquina aislado: 107/107 funciones, 735 bytes. Los tipos generados describen desplazamientos y operaciones, no identidades de clases ya demostradas.
• src/reconstructed/game_winmain_65d0e0.c reconstruye WinMain, una función real del arranque. python tools/verify_relocated_functions.py resuelve sus siete referencias COFF con las direcciones originales y confirma sus 69 bytes exactos. Hay también funciones de instancia única, creación y liberación de un hilo, actualización, opciones, salida de red, destructores y operaciones de contenedor: 1 006 funciones C/C++ y 35 872 bytes verificados a nivel de objeto. Ver notes/game_entry.md, notes/update_worker.md y notes/template_recovery.md.
• src/resources/ conserva los 30 recursos PE como archivos individuales y un script raw_resources.rc en el orden original. python tools/build_link_probe.py genera un PE experimental con VC++ 2003 y llvm-cvtres; python tools/verify_resources_res.py verifica los identificadores, idiomas y 38 036 bytes de contenido; python tools/compare_resource_layout.py confirma que los 40 960 bytes de .rsrc tienen cero diferencias tras ajustar las 30 RVA que dependen de la posición de la sección. El PE experimental no contiene el juego.
• notes/pe_manifest.json registra las cinco secciones, cabeceras, TLS y las 287 importaciones de 12 DLL; 30 importaciones de WS2_32.dll usan ordinal. python tools/build_import_probe.py y python tools/compare_import_probe.py verifican los 287 símbolos, hints, ordinales, tamaños y posiciones relativas de bloques IAT. La prueba C base coloca 10/287 entradas en su posición física; la variante ordenada descrita abajo alcanza 287/287. Detalles en notes/imports.md.
• python tools/probe_import_full_permutation.py mide e invierte el orden que aplica el enlazador a 287 referencias COFF. python tools/build_combined_probe.py --ordered-imports produce una prueba integrada con 287/287 imports en su posición IAT original, además del núcleo de .rdata, .data y .tls exactos. Los valores de IAT y la cola de metadatos todavía difieren; ver notes/imports.md.
• python tools/build_tls_probe.py y python tools/compare_tls_probe.py verifican una hipótesis de enlace TLS: una declaración __declspec(thread) de ocho bytes junto con /MERGE:.CRT=.data produce el mismo orden de cinco secciones, plantilla TLS de 12 bytes, .tls de 13 bytes virtuales y 4 096 bytes en disco idénticos, y tabla de callbacks en .data (14/14 comprobaciones). Es una prueba de formato, no el TLS semántico del juego.
• notes/game_entry.md documenta la ruta start → WinMain → GameEntryAndMainLoop y las funciones de línea de comandos, configuración y editor renombradas en IDA.
• src/data/ contiene una representación NASM de los 110 592 bytes inicializados de .data, con 2 005 referencias simbólicas candidatas. python tools/verify_data_object.py verifica todos sus bytes tras relocación. python tools/build_data_probe.py y python tools/compare_data_probe.py confirman que el PE de prueba conserva una sola .data con los mismos bytes, tamaños y atributos; los 2 442 876 bytes de BSS se generan como símbolo común C. Los alias absolutos y las referencias inferidas son provisionales; ver notes/data.md.
• src/rdata/core.asm representa los 446 240 bytes centrales de .rdata, con 12 028 referencias marcadas por IDA. python tools/verify_rdata_core.py verifica el objeto; python tools/build_combined_probe.py integra datos, imports, TLS y recursos. En esa prueba con bibliotecas de importación, la IAT y la cola todavía difieren. La prueba estática siguiente reproduce toda .rdata. Ver notes/rdata.md.
• src/rdata/import_prefix.asm y import_tail.asm representan también la IAT y los metadatos de importación, con símbolos para 287 imports. python tools/build_static_import_probe.py --original-rvas y python tools/verify_static_import_layout.py verifican un PE de prueba del mismo tamaño que el original: las cuatro secciones no ejecutables (610 304 bytes) coinciden por completo, incluidas sus RVA y directorios PE. Su .text es provisional y no implementa el juego. Ver notes/static_imports.md.
• src/pe/header_template.asm representa los 4 096 bytes de la cabecera PE; el enlace la ensambla y aplica tras comprobar la disposición de las secciones. El verificador confirma que cabecera y cuatro secciones no ejecutables son idénticas, y que todas las diferencias restantes se encuentran en .text. Ver notes/pe_header.md.
• python tools/build_from_saved_sources.py recompila las 13 624 fuentes de función (C/C++ y ensamblador integrado) recuperadas, comprueba sus bytes contra el mapa guardado y enlaza el PE sin leer orig/gbr.exe. Los tramos de biblioteca proceden de ese mapa. Ver notes/source_only_build.md.
• python tools/build_static_import_probe.py --recovered-text recompila esas funciones, integra los objetos del runtime y crea build/recovered_text_layout_probe.exe. python tools/compare_exe.py build/recovered_text_layout_probe.exe confirma EXACT MATCH: 4 456 448 bytes y SHA-256 F8B9518FFE31CBBB1C2C4236426DB866295AC9BE4C13794537B999B05AA647F7. Ver notes/code_layout.md.
• toolchain/vc71/lib/libcmt.lib contiene la entrada CRT original y funciones adicionales con coincidencia de objeto y relocaciones; libcpmt.lib aporta tres más. La prueba integrada reproduce 13 970 funciones en 16 615 tramos exactos (3 632 610 bytes), incluida la entrada real y 197 funciones recuperadas fuera del inventario original. El código IDA aún sin función recompilada se incorpora desde src/text/orphan_code.json; ver notes/crt_runtime.md, notes/large_functions.md, notes/hidden_seh.md y notes/hidden_entries.md.
• src/text/ida_data.bin y ida_data_manifest.json contienen los 173 314 bytes de datos de .text dentro del tamaño virtual de la sección. src/text/orphan_code.json conserva 51 959 bytes clasificados como código y 25 sin clasificar fuera de los tramos de funciones de IDA. tools/analyze_remaining_text.py confirma cero diferencias en .text.
• tools/compare_exe.py compara cualquier compilación candidata con el original y señala la primera diferencia.

PE32 x86; base 0x400000; punto de entrada 0x766AA7; alineación de secciones y archivo 0x1000; fecha PE 2006-06-09 14:32:04 UTC. Secciones: .text, .rdata, .data, .tls, .rsrc. No hay datos añadidos al final del PE. La entrada inicia el runtime de C y llama a WinMain en 0x65D0E0, que transfiere el control a 0x74D590.

1. Revisar y tipar el pseudocódigo del juego, separándolo del runtime y las bibliotecas estáticas. Convertir funciones a C/C++ y validar su código máquina con tools/verify_matched_functions.py.
2. Recuperar estructuras, datos, tablas, inicializadores, TLS, importaciones, saltos y código ensamblador que no pueda expresarse fielmente en C/C++.
3. Reconstruir unidades de compilación, opciones de compilador y enlazador, orden de objetos y bibliotecas. Compilar una primera candidata real.
4. Iterar con python tools/compare_exe.py build/gbr.exe hasta igualdad completa de bytes y SHA-256.

El pseudocódigo exportado conserva su dirección original para facilitar la trazabilidad.