某次热身赛re方向wp

base64，只不过换了一个表，没有任何包装，这个总能做了吧

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int flag_len; // [rsp+4h] [rbp-2Ch]
  char *encoded; // [rsp+8h] [rbp-28h]
  char flag[24]; // [rsp+10h] [rbp-20h] BYREF
  unsigned __int64 v7; // [rsp+28h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  read(0, flag, 0x15u);
  flag_len = strlen(flag);
  encoded = (char *)malloc(4 * flag_len / 3 + 4);
  if ( encoded )
  {
    base64_custom_encode((const unsigned __int8 *)flag, flag_len, encoded);
    if ( !strcmp(encoded, "zNoHvOEJwug8z9sH0NQH0NQH0NQU") )
      puts("success");
    else
      puts("fail");
    free(encoded);
    return 0;
  }
  else
  {
    fwrite("malloc failed\n", 1u, 0xEu, stderr);
    return 1;
  }
}

看到base64_custom_encode函数

void __cdecl base64_custom_encode(const unsigned __int8 *input, int len, char *output)
{
  int v3; // eax
  int v4; // eax
  int v5; // eax
  int i; // [rsp+1Ch] [rbp-Ch]
  int j; // [rsp+20h] [rbp-8h]
  unsigned int triple; // [rsp+24h] [rbp-4h]
  unsigned int triplea; // [rsp+24h] [rbp-4h]
  unsigned int tripleb; // [rsp+24h] [rbp-4h]

  i = 0;
  j = 0;
  while ( len > i + 2 )
  {
    triple = (input[i + 1] << 8) | (input[i] << 16) | input[i + 2];
    output[j] = custom_b64_table[(triple >> 18) & 0x3F];
    output[j + 1] = custom_b64_table[(triple >> 12) & 0x3F];
    output[j + 2] = custom_b64_table[(triple >> 6) & 0x3F];
    v3 = j + 3;
    j += 4;
    output[v3] = custom_b64_table[triple & 0x3F];
    i += 3;
  }
  if ( len == i + 1 )
  {
    triplea = input[i] << 16;
    output[j] = custom_b64_table[(input[i] >> 2) & 0x3F];
    output[j + 1] = custom_b64_table[(triplea >> 12) & 0x3F];
    output[j + 2] = 61;
    v4 = j + 3;
    j += 4;
    output[v4] = 61;
  }
  else if ( len == i + 2 )
  {
    tripleb = (input[i] << 16) | (input[i + 1] << 8);
    output[j] = custom_b64_table[(tripleb >> 18) & 0x3F];
    output[j + 1] = custom_b64_table[(tripleb >> 12) & 0x3F];
    output[j + 2] = custom_b64_table[(tripleb >> 6) & 0x3F];
    v5 = j + 3;
    j += 4;
    output[v5] = 61;
  }
  output[j] = 0;
}

再看到custom_b64_table，双击

custom_b64_table db 'XYZabcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVW'

拿到自定义的base64编码表

直接找在线工具http://web.chacuo.net/netbasex

image-20260629145950930

sdpc{rererepwnpwnpwn}

或者手搓python

STANDARD_ALPHABET = "XYZabcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVW"


def encode(data: str, alphabet: str = STANDARD_ALPHABET) -> str:
    result = []
    for i in range(0, len(data), 3): #步长为3
        chunk = data[i : i + 3] #三个一组
        value = ord(chunk[0]) << 16
        if len(chunk) > 1:
            value |= ord(chunk[1]) << 8
        if len(chunk) > 2:
            value |= ord(chunk[2])
        for j in range(4):
            if j < len(chunk) + 1:
                result.append(alphabet[(value >> (18 - j * 6)) & 0x3F])
            else:
                result.append("=")
    return "".join(result)


def decode(data: str, alphabet: str = STANDARD_ALPHABET) -> str:
    padding = data.count("=")
    data = data.rstrip("=")
    result = []
    for i in range(0, len(data), 4):
        chunk = data[i : i + 4]
        value = 0
        for j, c in enumerate(chunk):
            value |= alphabet.index(c) << (18 - j * 6)
        n = 4 - padding if i >= len(data) - 4 else 4 #判断是否为最后一组
        for j in range(n - 1):
            result.append(chr((value >> (16 - j * 8)) & 0xFF))
    return "".join(result)

a=decode("zNoHvOEJwug8z9sH0NQH0NQH0NQU")
print(a)

如果脚本或代码有看不懂的，可以用以下提示词

把这段代码当作我完全不会编程来解释：逐行说明每行代码做了什么、为什么这样做，以及整个程序的功能。用最通俗的语言，不要跳过任何基础概念，包括函数用法。

不会吧，直接给class文件还不会做吗

给了一个.class文件

jadx打开

package defpackage;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Scanner;

/* renamed from: xor3  reason: default package */
/* loaded from: xor3.class */
public class xor3 {
    private static final byte[] TARGET = {17, 6, 18, 1, 25, 16, 7, 18, 21, 12, 18, 21, 12, 18, 21, 12, 31};

    public static void hello() {
        System.out.println("Hello, can you reverse it too");
    }

    public static void main(String[] strArr) {
        hello();
        System.out.println("please enter your flag");
        Scanner scanner = new Scanner(System.in);
        String nextLine = scanner.nextLine();
        scanner.close();
        byte[] bytes = nextLine.getBytes(StandardCharsets.ISO_8859_1);
        byte[] bArr = new byte[bytes.length];
        for (int i = 0; i < bytes.length; i++) {
            bArr[i] = (byte) (bytes[i] ^ 98);
        }
        System.out.print("your xor result is:[");
        for (int i2 = 0; i2 < bArr.length; i2++) {
            if (i2 > 0) {
                System.out.print("");
            }
            System.out.printf("%d", Integer.valueOf(bArr[i2] & 255));
        }
        System.out.println("]");
        if (Arrays.equals(bArr, TARGET)) {
            System.out.println("Congratulations! You have successfully solved the challenge");
        } else {
            System.out.println("Sorry, you have failed the challenge");
        }
    }
}

依旧ai提示词学习代码

关键点在于把输入与98异或，注意255按位与是在输出时进行，不影响比较

我们只需要把TARGET = {17, 6, 18, 1, 25, 16, 7, 18, 21, 12, 18, 21, 12, 18, 21, 12, 31};与98异或就可以

使用工具的过程中出现了一点问题

cyberchef和随波逐流一开始都不好用

发给ai说是把17识别成1和7了...

仍不知道如何把输入的类型改为数字而不是文本....

解决方法是先转成16进制

但是问题又来了，这俩工具在转换进制的使用也会识别错误

换一个工具https://www.rapidtables.com/convert/number/decimal-to-hex.html

转换结果

11 06 12 01 19 07 12 15 0C 12 15 0C 12 15 0C 12 15 0C 1F

与62进行16进制异或

或者干脆别折腾了，老老实实学python

TARGET = [17, 6, 18, 1, 25, 16, 7, 18, 21, 12, 18, 21, 12, 18, 21, 12, 31]
result = []
for i in TARGET:
    result.append(chr(i ^ 98))
print(''.join(result))

sdpc{repwnpwnpwn}

upx

放到Exeinfo PE看一眼

Detected UPX!

先脱壳然后放ida

int __fastcall main(int argc, const char **argv, const char **envp)
{
  double v3; // xmm0_8
  int random_number; // [rsp+4h] [rbp-4Ch]
  _BYTE v6[56]; // [rsp+10h] [rbp-40h] BYREF
  unsigned __int64 v7; // [rsp+48h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  puts("=== UPX Packed Program with Hidden Flag ===");
  puts("This program is packed with UPX for demonstration purposes.");
  puts("Try to unpack it using UPX or other unpacking tools!\n");
  useless_function("Try to unpack it using UPX or other unpacking tools!\n", argv);
  another_useless_function();
  random_number = generate_random_number();
  printf("Random number: %d\n", random_number);
  v3 = complex_calculation(100);
  printf("Complex calculation result: %.2f\n", v3);
  printf("\nEnter the flag to verify: ");
  __isoc99_scanf("%49s", v6);
  if ( (unsigned int)validate_input(v6) )
    puts("\nCongratulations! You found the correct flag!");
  else
    puts("\nIncorrect flag. Please try again.");
  return 0;
}

前面输出两个随机数烟雾弹

关键部分

__isoc99_scanf("%49s", v6);
if ( (unsigned int)validate_input(v6) )
  puts("\nCongratulations! You found the correct flag!");

__isoc99_scanf("%49s", v6);

  • __isoc99_scanf是scanf 的标准版本，_isoc99 是 GLIBC 里的版本标记。

  • scanf — C 标准库函数，读用户输入

  • __isoc99_scanf — 编译时链接到了 ISO C99 标准 版本的 scanf，功能完全一样，只是符号名带版本后缀

  • %49s — 读字符串，限制长度 49，防止溢出

  • v6 — 就是一个 char v6[56] 数组，用来存你输入的 flag

跟进validate_input(v6)看逻辑

_BOOL8 __fastcall validate_input(const char *s1)
{
  char s2[56]; // [rsp+10h] [rbp-40h] BYREF
  unsigned __int64 v3; // [rsp+48h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  decrypt_flag((__int64)s2);
  return strcmp(s1, s2) == 0;
}

v3是金丝雀

跟进decrypt_flag函数

__int64 __fastcall decrypt_flag(__int64 p_s2)
{
  __int64 result; // rax
  int i; // [rsp+10h] [rbp-8h]

  for ( i = 0; ; ++i )
  {
    result = encrypted_flag[i];
    if ( !(_BYTE)result )
      break;
    *(_BYTE *)(i + p_s2) = xor_key[i % 14] ^ encrypted_flag[i];
  }
  return result;
}

遍历encrypted_flag的值与xor_key的第1到14位的循环

.rodata:0000000000002020 encrypted_flag  db 3Eh, 5Ch, 33h, 38h, 28h, 36h, 2Ah, 3Fh, 35h, 38h, 3Ah
.rodata:0000000000002020                                         ; DATA XREF: decrypt_flag+21↑o
.rodata:0000000000002020                                         ; decrypt_flag+5E↑o
.rodata:000000000000202B                 db 14h, 30h, 29h, 20h, 6Fh, 37h, 31h, 30h, 37h, 3Ah, 22h
.rodata:0000000000002036                 db 31h, 3Dh, 30h, 25h, 1Ah, 30h, 2Bh, 6Fh, 25h, 3Ah, 32h
.rodata:0000000000002041                 db 2Eh, 3Eh, 5 dup(0)

xor_key         db 'X0R_SECRET_KEY'

补充一句，在汇编中，h后缀表示这是16进制

继续学python

key = 'X0R_SECRET_KEY'
eflag = [
    0x3E, 0x5C, 0x33, 0x38, 0x28, 0x36, 0x2A, 0x3F, 0x35, 0x38, 0x3A,
    0x14, 0x30, 0x29, 0x20, 0x6F, 0x37, 0x31, 0x30, 0x37, 0x3A, 0x22,
    0x31, 0x3D, 0x30, 0x25, 0x1A, 0x30, 0x2B, 0x6F, 0x25, 0x3A, 0x32,
    0x2E, 0x3E
]
dflag = []
for i in range(len(eflag)):
    dflag.append(chr(eflag[i] ^ ord(key[i % 14])))
print(''.join(dflag))

flag{simple_upx_encryption_is_weak}

真的是一点包装都没有的原始版的rc4

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int keylen; // [rsp+8h] [rbp-58h]
  unsigned __int8 *plaintext; // [rsp+18h] [rbp-48h]
  unsigned __int8 plaintext_str[21]; // [rsp+20h] [rbp-40h] BYREF
  unsigned __int8 content[21]; // [rsp+40h] [rbp-20h] BYREF
  unsigned __int64 v8; // [rsp+58h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  keylen = strlen("mysecret");
  *(_QWORD *)plaintext_str = 0xB966693F95CF918ALL;
  *(_QWORD *)&plaintext_str[8] = 0x636796D9DACB48EFLL;
  *(_DWORD *)&plaintext_str[16] = -1082017924;
  plaintext_str[20] = 123;
  read(0, content, 0x15u);
  plaintext = (unsigned __int8 *)malloc(0x15u);
  memcpy(plaintext, plaintext_str, 0x15u);
  printf("plaintext: %s\n", (const char *)plaintext_str);
  printf("key: %s\n", "mysecret");
  rc4("mysecret", keylen, plaintext, 21);
  if ( memcpy(plaintext, content, 0x15u) )
    printf("success");
  else
    printf("fail");
  free(plaintext);
  return 0;
}

Challenge_^平台不支持上传start.sh，bzImage等组件，想要通过运行测试的可以跟我要链接

.ko文件，直接放ida

__int64 xor_kmod_init()
{
  _fentry__();
  proc_create("xor_check", 438, 0, &xor_proc_fops);
  printk(&unk_1F0);
  return 0;
}

__int64 __fastcall xor_proc_write(__int64 a1, __int64 a2)
{
  unsigned __int64 n17_1; // rdx
  __int64 n17; // rbx
  __int64 n17_2; // rax
  _BYTE s1_[49]; // [rsp-31h] [rbp-31h] BYREF

  _fentry__(a1, a2);
  n17 = 17;
  *(_QWORD *)&s1_[17] = __readgsqword(0x28u);
  if ( n17_1 <= 0x11 )
    n17 = n17_1;
  _check_object_size(input_buffer, n17, 0);
  if ( copy_from_user(input_buffer, a2, n17) )
    return -14;
  if ( n17 && input_buffer[n17 - 1] != 10 && n17 == 17 )
  {
    for ( n17_2 = 0; n17_2 != 17; ++n17_2 )
      s1_[n17_2] = input_buffer[n17_2] ^ 0x62;
    if ( !memcmp(s1_, &TARGET, 0x11u) )
    {
      printk(&unk_190);
      return 17;
    }
    else
    {
      printk(&unk_1C8);
      return -22;
    }
  }
  else
  {
    printk(&unk_168);
    return -22;
  }
}

__int64 xor_kmod_exit()
{
  remove_proc_entry("xor_check", 0);
  return printk(&unk_234);
}

关键还是在于异或

for ( n17_2 = 0; n17_2 != 17; ++n17_2 )
   s1_[n17_2] = input_buffer[n17_2] ^ 0x62;
if ( !memcmp(s1_, &TARGET, 0x11u) )

取target与62进行16进制异或

11 06 12 01 19 10 07 12 15 0C 12 15 0C 1F
sdpc{repwnpwn}

学几个函数

proc_create("xor_check", 438, 0, &xor_proc_fops);
它做了以下几件事：

  • proc_create()：这是一个内核函数（别人已经写好的工具函数），作用是在 /proc 目录下创建一个文件。

    • /proc 是什么？Linux 系统里有一个特殊的目录叫 /proc，它里面的文件不是存在硬盘上的，而是内核虚拟出来的。你读/写这些文件，实际上是在和内核里的代码交互。比如你 cat /proc/cpuinfo 就能看到 CPU 信息。

  • 参数1 "xor_check"：文件的名字。所以这个文件就叫 /proc/xor_check

  • 参数2 438：这个数字是权限，用8进制看就是 0666。6 表示 "读写"，三个数字分别对应 "文件主人/同组人/其他人" 都能读写。这里所有人都可以读写这个文件。

  • 参数3 0：父目录设为空，意味着放在 /proc 根目录下

  • 参数4 &xor_proc_fops：最关键的一个参数。xor_proc_fops 是一个函数表（fops = file operations），这张表里记录了"当有人读这个文件时调用哪个函数"、"当有人写这个文件时调用哪个函数"。& 表示取这个表的地址（告诉内核这张表在哪）。在这个表里，写操作指向的就是下面的 xor_proc_write 函数。

_check_object_size(input_buffer, n17, 0);

  • _check_object_size()：又一个内核安全检查函数
  • 检查 input_buffer（存用户数据的缓冲区）有没有至少 n17 字节那么大，防止越界访问
  • 参数3 的 0 表示这是一个"读"操作检查

if ( copy_from_user(input_buffer, a2, n17) )
return -14;

  • copy_from_user()：把数据从用户空间复制到内核空间
    • 为什么需要这步？系统里有两块"地盘"：用户空间（普通程序待的地方）和内核空间（内核代码待的地方）。程序不能直接访问内核的地盘，需要通过 copy_from_user 这个"海关"来传输数据。
    • 参数1 input_buffer：数据要存到内核的哪个位置
    • 参数2 a2：从用户空间的哪个地址取数据
    • 参数3 n17：复制多少个字节

debugme

ida打开

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char Str[8]; // [rsp+20h] [rbp-30h] BYREF
  __int64 v5; // [rsp+28h] [rbp-28h]
  __int64 v6; // [rsp+30h] [rbp-20h]
  __int64 v7; // [rsp+38h] [rbp-18h]
  char v8; // [rsp+40h] [rbp-10h]

  _main();
  *(_QWORD *)Str = 0;
  v5 = 0;
  v6 = 0;
  v7 = 0;
  v8 = 0;
  puts("Please input the flag: ");
  scanf("%32s", Str);
  if ( strlen(Str) == 32 )
  {
    decode_flag(&flag);
    if ( !memcmp(Str, &flag, 0x20u) )
      puts("Right! ");
    else
      puts("Wrong! ");
  }
  else
  {
    puts("Length wrong! ");
  }
  return 0;
}

在比较处下断点，然后debug，输入任意32个字符，回车

image-20260702143252120

lea     rcx, flag           ; rcx = &flag (flag 缓冲区的地址)
call    decode_flag         ; 调用 RC4 解密函数，把加密数据解密到 flag 缓冲区
                            ; 执行完这行后，flag 地址处就是明文 flag 了
lea     rax, [rbp+Str]     ; rax = 用户输入的字符串地址
mov     r8d, 20h            ; r8 = 32 (第三个参数：比较长度 32 字节)
lea     rdx, flag           ; rdx = flag 地址 (第二个参数：解密后的 flag)
mov     rcx, rax            ; rcx = 用户输入地址 (第一个参数)
call    memcmp              ; 调用 memcmp(用户输入, 解密后flag, 32)

SDPCSEC{debug_to_do_1s_e53y}

ezida

直接打开然后ctrl+F就能搜到

依旧学习代码

Stream = __iob_func();

  • __iob_func()：获取标准输入/输出/错误流的信息。返回一个结构体数组，其中包含 stdin（键盘输入）、stdout（屏幕输出）等。
  • Stream 指向 stdin。
    fgets(Buffer, 100, Stream);
  • fgets = "file get string"，从文件读取一行文字。
    • 第一个参数 Buffer → 把读到的内容存入 Buffer 数组。
    • 第二个参数 100 → 最多读 99 个字符（留一个给字符串结尾标记 \0）。
    • 第三个参数 Stream → 从键盘（stdin）读。
  • 效果：你输入一行字按回车，这行字被存进 Buffer。

去掉换行符
Buffer[strcspn(Buffer, "\n")] = 0;

  • strcspn(Buffer, "\n") = "string complement span"，找到 Buffer 里第一个 "\n"（换行符）的位置。
    • 因为你按了回车，fgets 会把换行符也保留在 Buffer 末尾。
    • 例如你输入 abc\n，这个函数返回 3（\n 在第 3 个位置，从 0 开始数）。
  • Buffer[位置] = 0：把那个位置的换行符替换成 0（也就是字符串结束符 \0），相当于"剪掉换行符"。

检查长度
if ( strlen(Buffer) == correct_len )

  • strlen(Buffer) = "string length"，数一下 Buffer 里有多少个字符（遇到 \0 停止）。
  • correct_len：一个事先定义好的全局变量，值是 0x1f = 31。
  • if (...)：如果括号里的条件成立，就执行它下面的代码块；否则跳到 else。
    这句话在说：如果你输入的密码长度不等于 31，就去报错。
@WCP@VPh`gaL"`L&#L r&jL$#Lu"}wn

转16进制，放随波逐流异或

40 57 43 50 40 56 50 68 60 67 61 4c 22 60 4c 26 23 4c 20 72 26 6a 4c 24 23 4c 75 22 7d 77 6e

data = b'@WCP@VPh`gaL"`L&#L r&jL$#Lu"}wn'
print(bytes([b ^ 19 for b in data]).decode())

go^go=?

解压后只有三个关键文件：

  • GD1.exe
  • GD1.console.exe
  • GD1.pck

这里已经基本能判断是 Godot 导出的 Windows 游戏。原因很简单：

  • exe + .pck 是 Godot 很典型的发布结构。

调用工具反编译

E:\retools\gdre\gdre_tools.exe --headless 
--recover=E:\cod\_ctf_nxgodot\NXgodot\GD1.pck 
--output=E:\cod\_ctf_nxgodot\gdre_recover

或者直接打开E:\retools\gdre\gdre_tools.exe

把附件拖进去查看

重点在main.gdc

extends Node

@export var mob_scene: PackedScene
var score


var a = "000010000010000001101001000010000001000001100110000010000010000001101000000001100110000010010000000001101001000000011001000000011000000000100000000001100100000001100111000001110001000000100011000000010010000001110001000000100010000000100010000000011000000000010010000000100001000000011000000001100111000001100100000000010010000001100100000000010110000000010110000000010111000000010010000000010110000000011000000001101001000000100101000000100010000001101001000001100100000000011000000001101000000000100011000000010111000000010111000010010010\n"



var xor_key = 33

func _ready():
	pass

func _process(delta: float) -> void :
	pass

func game_over():
	$ScoreTimer.stop()
	$MobTimer.stop()
	$HUD.show_game_over()

func new_game():
	score = 0
	$Player.start($StartPosition.position)
	$StartTimer.start()
	$HUD.update_score(score)
	$HUD.show_message("Get Ready")
	get_tree().call_group("mobs", "queue_free")

func _on_mob_timer_timeout():
	var mob = mob_scene.instantiate()
	var mob_spawn_location = $MobPath / MobSpawnLocation
	mob_spawn_location.progress_ratio = randf()
	var direction = mob_spawn_location.rotation + PI / 2
	mob.position = mob_spawn_location.position
	direction += randf_range( - PI / 4, PI / 4)
	mob.rotation = direction
	var velocity = Vector2(randf_range(150.0, 250.0), 0.0)
	mob.linear_velocity = velocity.rotated(direction)
	add_child(mob)

func _on_score_timer_timeout():
	score += 1
	$HUD.update_score(score)


	if score == 177906:
		var result = ""
		for i in range(0, a.length(), 12):
			var bin_chunk = a.substr(i, 12)


			if bin_chunk.length() < 12: break


			var hundreds = bin_chunk.substr(0, 4).bin_to_int()
			var tens = bin_chunk.substr(4, 4).bin_to_int()
			var units = bin_chunk.substr(8, 4).bin_to_int()
			var mixed_val = hundreds * 100 + tens * 10 + units


			var decrypted_val = mixed_val ^ xor_key

			result += String.chr(decrypted_val)

		$HUD.show_message(result)

func _on_start_timer_timeout():
	$MobTimer.start()
	$ScoreTimer.start()

挑重点，把a分为12个字符一组

一组内分为三块，每块4字符，转换成10进制，分别乘100、10、1再相加，之后与33异或，拼接得到result

继续学习python

a = "000010000010000001101001000010000001000001100110000010000010000001101000000001100110000010010000000001101001000000011001000000011000000000100000000001100100000001100111000001110001000000100011000000010010000001110001000000100010000000100010000000011000000000010010000000100001000000011000000001100111000001100100000000010010000001100100000000010110000000010110000000010111000000010010000000010110000000011000000001101001000000100101000000100010000001101001000001100100000000011000000001101000000000100011000000010111000000010111000010010010"

result = ""
for i in range(0, len(a), 12):
    b = a[i:i+4]      
    c = a[i+4:i+8]    
    d = a[i+8:i+12]   
    
    e = int(b, 2) * 100 + int(c, 2) * 10 + int(d, 2)
    result += chr(e ^ 33)
print(result)

其实我有个想法，可不可以修改他的源码，把游戏成功条件降低，让他自己吐出flag呢

gdre_tools.exe --headless --compile='E:\cod\_ctf_nxgodot\gdre_recover\main.gd' --bytecode='4.5.0' --output='E:\cod\_ctf_nxgodot\repack_build'

gdre_tools.exe --headless --pck-patch='E:\cod\_ctf_nxgodot\NXgodot\GD1.pck' --patch-file='E:\cod\_ctf_nxgodot\repack_build\main.gdc=res://main.gdc' --output='E:\cod\_ctf_nxgodot\NXgodot\GD1_patched.pck'

image-20260702182211288

关于这道题，还有几个问题

1.pck文件，gdc文件，gd文件是什么

2.gdre_tools.exe --headless --compile='E:\cod\_ctf_nxgodot\gdre_recover\main.gd' --bytecode='4.5.0' --output='E:\cod\_ctf_nxgodot\repack_build'
gdre_tools.exe --headless --pck-patch='E:\cod\_ctf_nxgodot\NXgodot\GD1.pck' --patch-file='E:\cod\_ctf_nxgodot\repack_build\main.gdc=res://main.gdc' --output='E:\cod\_ctf_nxgodot\NXgodot\GD1_patched.pck' 这两个命令是干什么的

1. pck、gdc、gd 分别是什么

gd

  • 这是 Godot 的脚本源码。
  • 类似 Python 风格，给场景节点写逻辑。
  • 你恢复出来的 main.gd、player.gd 就是源码。

可以理解成：

  • gd = 人能直接读和改的脚本

gdc

  • 这是 GDScript 编译后的字节码文件。
  • 运行时 Godot 会加载它执行。
  • 它不是原生机器码，但也不是源码，中间态。
  • CTF 里常见做法就是只给你 .gdc，不直接给 .gd。

可以理解成：

  • gdc = Godot 脚本的编译产物

pck

  • 这是 Godot 的资源包/打包文件。
  • 里面会装：
    • 场景
    • 贴图
    • 音频
    • 配置
    • 脚本源码或脚本字节码
  • 发布游戏时，Godot 常见结构就是：
    • game.exe
    • game.pck

可以理解成：

  • pck = 游戏资源总包
  • gd/gdc 往往都装在 pck 里

这题里关系就是：

main.gd      源码
   ↓ 编译
main.gdc     字节码
   ↓ 打包进
GD1.pck      资源包
   ↓ 被
GD1.exe      运行

2. 第一个命令是干什么的

你的第一个命令：

gdre_tools.exe --headless --compile='E:\cod\_ctf_nxgodot\gdre_recover\main.gd' --bytecode='4.5.0' --output='E:\cod\_ctf_nxgodot\repack_build'

作用是：

  • 把你修改过的 main.gd
  • 按 Godot 4.5 对应的字节码格式
  • 编译回 main.gdc
  • 输出到 E:\cod\_ctf_nxgodot\repack_build

拆开看：

  • --headless
    • 无界面 CLI 模式运行
  • --compile='...main.gd'
    • 指定要编译哪个 GDScript 源码文件
  • --bytecode='4.5.0'
    • 指定编译成哪一版 Godot 字节码
    • 因为原题识别出来是 4.5.x，所以这里要对齐版本
    • 否则新编译出来的 gdc 可能和原游戏不兼容
  • --output='...repack_build'
    • 指定编译产物输出目录

所以这条命令本质上就是：

main.gd -> main.gdc

3. 第二个命令是干什么的

你的第二个命令：

gdre_tools.exe --headless --pck-patch='E:\cod\_ctf_nxgodot\NXgodot\GD1.pck' --patch-file='E:\cod\_ctf_nxgodot\repack_build\main.gdc=res://main.gdc' --output='E:\cod\_ctf_nxgodot\NXgodot\GD1_patched.pck'

作用是：

  • 以原始 GD1.pck 为基础
  • 把里面原本的 res://main.gdc
  • 替换成你刚编译出来的新 main.gdc
  • 生成一个新的 patched 包 GD1_patched.pck

拆开看：

  • --pck-patch='...GD1.pck'
    • 说明要 patch 的目标包是哪个
  • --patch-file='本地文件=包内路径'
    • 左边：
      • E:\cod\_ctf_nxgodot\repack_build\main.gdc
      • 这是你本地新编译出来的文件
    • 右边：
      • res://main.gdc
      • 这是它在 Godot 项目里的逻辑路径
      • 意思是“用左边这个文件替换包里原来的 res://main.gdc”
  • --output='...GD1_patched.pck'
    • 把替换后的新包写到哪里

所以这条命令本质上就是：

新 main.gdc -> 替换进原始 GD1.pck

4. 为什么不是直接把 main.gd 扔回 pck

因为原游戏原本加载的是：

  • res://main.gdc

不是：

  • res://main.gd

所以你不能只改源码文件名就塞回去。更稳的做法是：

  1. 先把 .gd 编译回 .gdc
  2. 再用新的 .gdc 去替换包里的旧 .gdc

这就是你这两条命令连起来的意义。

5. 两条命令连起来的完整语义

连起来就是这条链：

修改 main.gd
   ↓
编译成 main.gdc
   ↓
把新的 main.gdc 替换进 GD1.pck
   ↓
得到可运行的 patched 版本

也就是：

  • 第一条命令负责“把源码变回游戏能执行的格式”
  • 第二条命令负责“把新逻辑塞回原游戏包”

6. 用一句最短的话总结

  • gd 是源码
  • gdc 是编译后的 Godot 脚本
  • pck 是 Godot 游戏资源包

两条命令分别是：

  1. gd -> gdc
  2. 新 gdc -> patch 进 pck

aes，用的库封装，逸最简单的一集

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int i; // [rsp+Ch] [rbp-144h]
  AES_KEY aes_key; // [rsp+20h] [rbp-130h] BYREF
  char buf[16]; // [rsp+120h] [rbp-30h] BYREF
  char ciphertext[24]; // [rsp+130h] [rbp-20h] BYREF
  unsigned __int64 v8; // [rsp+148h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  read(0, buf, 0x10u);
  if ( strlen("sdpc_key_123456_") == 16 )
  {
    AES_set_encrypt_key("sdpc_key_123456_", 128, &aes_key);
    AES_encrypt(buf, ciphertext, &aes_key);
    printf("Ciphertext: ");
    for ( i = 0; i <= 15; ++i )
      printf("%02x", (unsigned __int8)ciphertext[i]);
    putchar(10);
    if ( !strcmp(ciphertext, "ae2f680621fb34d6a8ee7019069ded5e") )
      puts("fail");
    else
      puts("success");
    return 0;
  }
  else
  {
    fwrite("Key must be 16 bytes\n", 1u, 0x15u, stderr);
    return 1;
  }
}

已知密文密钥，直接解密呗

解出来是

sdpc{rerepwnpwnp

？？？

from Crypto.Cipher import AES
key = b"sdpc_key_123456_"
ct = bytes.fromhex("ae2f680621fb34d6a8ee7019069ded5e")
pt = AES.new(key, AES.MODE_ECB).decrypt(ct)
print(pt)

ryo ? soyo？ mio？

ida打开

int __fastcall main(int argc, const char **argv, const char **envp)
{
  Stream *Stream; // rax
  unsigned int v4; // eax
  char Buffer[1024]; // [rsp+20h] [rbp-60h] BYREF
  char *Str1; // [rsp+420h] [rbp+3A0h]
  char *Str2; // [rsp+428h] [rbp+3A8h]

  _main();
  Str2 = "U0RQQ1NFQ3t3ZWxjb21lX05ld1N0YXJzfQ==";
  puts("please input your flag:");
  Stream = __iob_func();
  fgets(Buffer, 1024, Stream);
  Buffer[strcspn(Buffer, "\n")] = 0;
  v4 = strlen(Buffer);
  Str1 = (char *)base64_encode(Buffer, v4);
  if ( !Str1 )
    return 1;
  if ( !strcmp(Str1, Str2) )
    puts("Correct");
  else
    puts("False");
  free(Str1);
  return 0;
}

直接base64解码

SDPCSEC{welcome_NewStars}

逸别卷了，喝一杯茶休息一下

int __fastcall main(int argc, const char **argv, const char **envp)
{
  size_t n; // rax
  size_t n_1; // rax
  uint32_t dest_[2]; // [rsp+18h] [rbp-28h] BYREF
  uint32_t key[4]; // [rsp+20h] [rbp-20h] BYREF
  char buf[8]; // [rsp+30h] [rbp-10h] BYREF
  unsigned __int64 v9; // [rsp+38h] [rbp-8h]

  v9 = __readfsqword(0x28u);
  read(0, buf, 8u);
  memset(key, 0, sizeof(key));
  n = strlen("sdpc");
  memcpy(key, "sdpc", n);
  *(_QWORD *)dest_ = 0;
  n_1 = strlen(buf);
  memcpy(dest_, buf, n_1);
  tea_encrypt(dest_, key);
  printf("Encrypted: %08x%08x\n", dest_[0], dest_[1]);
  if ( !strcmp((const char *)dest_, " 9dcfccd3088d1064") )
    puts("fail");
  else
    puts("success");
  return 0;
}

read(0, buf, 8u);
从标准输入（键盘）读最多 8 个字节，存到 buf 数组里。

  • read 是一个系统提供的基础函数。
  • 第一个参数 0 = 标准输入（键盘）。
  • 第二个参数 buf = 读到的内容存到哪里。
  • 第三个参数 8u = 最多读 8 个字节。
    所以你在键盘上打东西，程序会取前 8 个字符存到 buf。

memset(key, 0, sizeof(key));
把 key 数组的每一个字节都设为 0。这叫清零。

  • memset = memory set（设置内存）。
  • 为什么这么做？因为 key 声明时没有指定初始值，里面的内容是垃圾值（内存里之前残留的数据），必须先清零才能用。
sizeof(int)    // → 4     (int 占 4 字节)
sizeof(char)   // → 1     (char 占 1 字节)
sizeof("abc")  // → 4     (字符串 "abc" 实际是 'a','b','c','\0'，共 4 字节)
int arr[10];
sizeof(arr)    // → 40    (10 × 4 = 40 字节)
用来返回目标在内存中占多少字节

memcpy(key, "sdpc", n);
memcpy = memory copy（复制内存）。把字符串 "sdpc" 的 4 个字节复制到 key 数组的开头。
做完这一步，key 数组的内容是：
key[0] = "sdpc" 的前 4 个字节（'s','d','p','c'）
key[1] = 0
key[2] = 0
key[3] = 0

(QWORD *)dest = 0;
把 dest_ 数组的前 8 个字节全部设为 0。_QWORD 是 8 字节整数， 是解引用（把 dest_ 当成那 8 字节看），效果相当于 dest_[0] = 0 且 dest_[1] = 0。就是清零。

memcpy(dest_, buf, n_1);
把你输入的 n_1 个字符复制到 dest_ 数组里。dest_ 的前 4 字节被当作一个叫 dest_[0] 的整数，后 4 字节被当作 dest_[1]。
为什么要这样搞？因为 dest_ 声明的是 uint32_t 数组（每个元素 4 字节），但你输入的是字符串（一个一个字符）。它用 memcpy 把这 8 个字符直接覆盖到 dest_ 的 8 字节上。这样，你输入的 8 个字符就变成了两个 32 位整数——这是把字符串当数字去加密的前提。

其实逻辑很清晰，c2CwY3CyZXBlcmCwd2Cwd2Cwd2C9先base64解密得到一些乱码

这串乱码在cyberchef中显示是21字符，但是输入进程序就成27了，不明白

找ai想了个法

python3 - <<'PY' | /lib64/ld-linux-x86-64.so.2 ./base64cpp
import sys
sys.stdout.buffer.write(bytes.fromhex('7360b06370b26570657260b07760b07760b07760bd') + b'\n')
PY

这么多方程我咋解啊

拿到附件发现是python写的exe

先解包拿到.pyc

python pyinstxtractor.py E:\firefox\solve_flag.exe

再反编译，并保存到aaa.py

pycdc E:\retools\pyinstxtractor-2026.04\solve_flag.exe_extracted\solve_flag.pyc -o aaa.py

看aaa.py

# Source Generated with Decompyle++
# File: solve_flag.pyc (Python 3.11)


def check(flag):
    if 47 * flag[0] + 41 * flag[1] + 32 * flag[2] + 56 * flag[3] + 52 * flag[4] + 67 * flag[5] + 13 * flag[6] + 25 * flag[7] + 20 * flag[8] + 98 * flag[9] + 88 * flag[10] + 65 * flag[11] + 82 * flag[12] + 92 * flag[13] + 3 * flag[14] + 29 * flag[15] + 93 * flag[16] + 88 * flag[17] + 45 * flag[18] + 58 * flag[19] + 40 * flag[20] + 72 * flag[21] + 99 * flag[22] + 10 * flag[23] + 94 * flag[24] + 62 * flag[25] + 82 * flag[26] + 92 * flag[27] + 23 * flag[28] + 46 * flag[29] + 55 * flag[30] + 72 * flag[31] + 44 * flag[32] + 9 * flag[33] + 65 * flag[34] + 42 * flag[35] == 176386 and 10 * flag[0] + 98 * flag[1] + 5 * flag[2] + 28 * flag[3] + 68 * flag[4] + 20 * flag[5] + 2 * flag[6] + 22 * flag[7] + 65 * flag[8] + 44 * flag[9] + 85 * flag[10] + 97 * flag[11] + 33 * flag[12] + 74 * flag[13] + 93 * flag[14] + 74 * flag[15] + 41 * flag[16] + 65 * flag[17] + 32 * flag[18] + 93 * flag[19] + 22 * flag[20] + 69 * flag[21] + 68 * flag[22] + 57 * flag[23] + 47 * flag[24] + 29 * flag[25] + 74 * flag[26] + 54 * flag[27] + 91 * flag[28] + 90 * flag[29] + 26 * flag[30] + 11 * flag[31] + 89 * flag[32] + 57 * flag[33] + 100 * flag[34] + 95 * flag[35] == 186050 and 25 * flag[0] + 22 * flag[1] + 54 * flag[2] + 5 * flag[3] + 8 * flag[4] + 3 * flag[5] + 12 * flag[6] + 70 * flag[7] + 25 * flag[8] + 61 * flag[9] + 68 * flag[10] + 12 * flag[11] + 27 * flag[12] + 42 * flag[13] + 83 * flag[14] + 91 * flag[15] + 67 * flag[16] + 46 * flag[17] + 8 * flag[18] + 45 * flag[19] + 94 * flag[20] + 80 * flag[21] + 69 * flag[22] + 95 * flag[23] + 12 * flag[24] + 21 * flag[25] + 94 * flag[26] + 82 * flag[27] + 93 * flag[28] + 41 * flag[29] + 4 * flag[30] + 56 * flag[31] + 92 * flag[32] + 77 * flag[33] + 15 * flag[34] + 30 * flag[35] == 154690 and 33 * flag[0] + 49 * flag[1] + 56 * flag[2] + 40 * flag[3] + 90 * flag[4] + 59 * flag[5] + 82 * flag[6] + 6 * flag[7] + 81 * flag[8] + 32 * flag[9] + 23 * flag[10] + 76 * flag[11] + 93 * flag[12] + 83 * flag[13] + 10 * flag[14] + 44 * flag[15] + 58 * flag[16] + 33 * flag[17] + 79 * flag[18] + 77 * flag[19] + 82 * flag[20] + 56 * flag[21] + 70 * flag[22] + 34 * flag[23] + 45 * flag[24] + 76 * flag[25] + 57 * flag[26] + 43 * flag[27] + 100 * flag[28] + 19 * flag[29] + 11 * flag[30] + 90 * flag[31] + 3 * flag[32] + 60 * flag[33] + 57 * flag[34] + 23 * flag[35] == 172116 and 65 * flag[0] + 70 * flag[1] + 20 * flag[2] + 32 * flag[3] + 75 * flag[4] + 30 * flag[5] + 3 * flag[6] + 78 * flag[7] + 35 * flag[8] + 45 * flag[9] + 95 * flag[10] + 93 * flag[11] + 52 * flag[12] + 32 * flag[13] + 88 * flag[14] + 94 * flag[15] + 67 * flag[16] + 34 * flag[17] + 91 * flag[18] + 88 * flag[19] + 31 * flag[20] + 61 * flag[21] + 17 * flag[22] + 99 * flag[23] + 100 * flag[24] + 49 * flag[25] + 4 * flag[26] + 60 * flag[27] + 81 * flag[28] + 88 * flag[29] + 43 * flag[30] + 34 * flag[31] + 30 * flag[32] + 52 * flag[33] + 18 * flag[34] + 100 * flag[35] == 190544 and 81 * flag[0] + 42 * flag[1] + 28 * flag[2] + 98 * flag[3] + 31 * flag[4] + 46 * flag[5] + 64 * flag[6] + 15 * flag[7] + 49 * flag[8] + 13 * flag[9] + 100 * flag[10] + 81 * flag[11] + 32 * flag[12] + 52 * flag[13] + 59 * flag[14] + 24 * flag[15] + 94 * flag[16] + 32 * flag[17] + 93 * flag[18] + 32 * flag[19] + 13 * flag[20] + 89 * flag[21] + 37 * flag[22] + 30 * flag[23] + 78 * flag[24] + 81 * flag[25] + 9 * flag[26] + 45 * flag[27] + 93 * flag[28] + 100 * flag[29] + 97 * flag[30] + 10 * flag[31] + 80 * flag[32] + 54 * flag[33] + 88 * flag[34] + 85 * flag[35] == 190323 and 76 * flag[0] + 54 * flag[1] + 5 * flag[2] + 14 * flag[3] + 62 * flag[4] + 44 * flag[5] + 24 * flag[6] + 29 * flag[7] + 85 * flag[8] + 87 * flag[9] + 19 * flag[10] + 3 * flag[11] + 65 * flag[12] + 24 * flag[13] + 92 * flag[14] + 37 * flag[15] + 57 * flag[16] + 20 * flag[17] + 45 * flag[18] + 5 * flag[19] + 13 * flag[20] + 91 * flag[21] + 92 * flag[22] + 75 * flag[23] + 36 * flag[24] + 79 * flag[25] + 12 * flag[26] + 22 * flag[27] + 75 * flag[28] + 82 * flag[29] + 28 * flag[30] + 82 * flag[31] + 24 * flag[32] + 53 * flag[33] + 56 * flag[34] + 92 * flag[35] == 162017 and 53 * flag[0] + 52 * flag[1] + 72 * flag[2] + 23 * flag[3] + 26 * flag[4] + 13 * flag[5] + 62 * flag[6] + 96 * flag[7] + 67 * flag[8] + 96 * flag[9] + 66 * flag[10] + 41 * flag[11] + 5 * flag[12] + 18 * flag[13] + 37 * flag[14] + 13 * flag[15] + 61 * flag[16] + 71 * flag[17] + 91 * flag[18] + 96 * flag[19] + 56 * flag[20] + 3 * flag[21] + 65 * flag[22] + 14 * flag[23] + 57 * flag[24] + 69 * flag[25] + 75 * flag[26] + 68 * flag[27] + 10 * flag[28] + 60 * flag[29] + 62 * flag[30] + 95 * flag[31] + 53 * flag[32] + 19 * flag[33] + 7 * flag[34] + 56 * flag[35] == 165118 and 26 * flag[0] + 7 * flag[1] + 49 * flag[2] + 14 * flag[3] + 36 * flag[4] + 87 * flag[5] + 21 * flag[6] + 35 * flag[7] + 15 * flag[8] + 91 * flag[9] + 15 * flag[10] + 100 * flag[11] + 8 * flag[12] + 32 * flag[13] + 100 * flag[14] + 35 * flag[15] + 66 * flag[16] + 3 * flag[17] + 79 * flag[18] + 96 * flag[19] + 82 * flag[20] + 95 * flag[21] + 68 * flag[22] + 13 * flag[23] + 86 * flag[24] + 51 * flag[25] + 24 * flag[26] + 76 * flag[27] + 30 * flag[28] + 60 * flag[29] + 29 * flag[30] + 70 * flag[31] + 40 * flag[32] + 90 * flag[33] + 44 * flag[34] + 3 * flag[35] == 153332 and 47 * flag[0] + 19 * flag[1] + 37 * flag[2] + 93 * flag[3] + 73 * flag[4] + 30 * flag[5] + 45 * flag[6] + 47 * flag[7] + 72 * flag[8] + 85 * flag[9] + 37 * flag[10] + 68 * flag[11] + 89 * flag[12] + 34 * flag[13] + 4 * flag[14] + 50 * flag[15] + 87 * flag[16] + 33 * flag[17] + 87 * flag[18] + 43 * flag[19] + 9 * flag[20] + 61 * flag[21] + 93 * flag[22] + 49 * flag[23] + 74 * flag[24] + 49 * flag[25] + 68 * flag[26] + 29 * flag[27] + 54 * flag[28] + 54 * flag[29] + 37 * flag[30] + 79 * flag[31] + 33 * flag[32] + 65 * flag[33] + 59 * flag[34] + 15 * flag[35] == 168472 and 79 * flag[0] + 73 * flag[1] + 60 * flag[2] + 62 * flag[3] + 25 * flag[4] + 16 * flag[5] + 77 * flag[6] + 81 * flag[7] + 79 * flag[8] + 31 * flag[9] + 82 * flag[10] + 84 * flag[11] + 62 * flag[12] + 36 * flag[13] + 18 * flag[14] + 20 * flag[15] + 46 * flag[16] + 57 * flag[17] + 21 * flag[18] + 40 * flag[19] + 3 * flag[20] + 50 * flag[21] + 58 * flag[22] + 80 * flag[23] + 84 * flag[24] + 71 * flag[25] + 87 * flag[26] + 3 * flag[27] + 13 * flag[28] + 77 * flag[29] + 83 * flag[30] + 39 * flag[31] + 55 * flag[32] + 34 * flag[33] + 41 * flag[34] + 63 * flag[35] == 178706 and 7 * flag[0] + 50 * flag[1] + 26 * flag[2] + 79 * flag[3] + 21 * flag[4] + 42 * flag[5] + 83 * flag[6] + 94 * flag[7] + 63 * flag[8] + 83 * flag[9] + 3 * flag[10] + 68 * flag[11] + 25 * flag[12] + 91 * flag[13] + 3 * flag[14] + 5 * flag[15] + 17 * flag[16] + 61 * flag[17] + 3 * flag[18] + 40 * flag[19] + 87 * flag[20] + 11 * flag[21] + 27 * flag[22] + 74 * flag[23] + 73 * flag[24] + 21 * flag[25] + 56 * flag[26] + 46 * flag[27] + 36 * flag[28] + 24 * flag[29] + 14 * flag[30] + 63 * flag[31] + 21 * flag[32] + 71 * flag[33] + 30 * flag[34] + 53 * flag[35] == 143852 and 57 * flag[0] + 51 * flag[1] + 49 * flag[2] + 15 * flag[3] + 94 * flag[4] + 34 * flag[5] + 27 * flag[6] + 5 * flag[7] + 100 * flag[8] + 68 * flag[9] + 67 * flag[10] + 81 * flag[11] + 10 * flag[12] + 5 * flag[13] + 85 * flag[14] + 70 * flag[15] + 80 * flag[16] + 20 * flag[17] + 89 * flag[18] + 30 * flag[19] + 84 * flag[20] + 35 * flag[21] + 41 * flag[22] + 87 * flag[23] + 75 * flag[24] + 67 * flag[25] + 20 * flag[26] + 33 * flag[27] + 29 * flag[28] + 6 * flag[29] + 97 * flag[30] + 25 * flag[31] + 10 * flag[32] + 18 * flag[33] + 23 * flag[34] + 30 * flag[35] == 154052 and 97 * flag[0] + 93 * flag[1] + 10 * flag[2] + 44 * flag[3] + 28 * flag[4] + 22 * flag[5] + 17 * flag[6] + 41 * flag[7] + 47 * flag[8] + 62 * flag[9] + 42 * flag[10] + 47 * flag[11] + 61 * flag[12] + 32 * flag[13] + 31 * flag[14] + 52 * flag[15] + 47 * flag[16] + 92 * flag[17] + 42 * flag[18] + 37 * flag[19] + 7 * flag[20] + 40 * flag[21] + 48 * flag[22] + 40 * flag[23] + 11 * flag[24] + 96 * flag[25] + 51 * flag[26] + 42 * flag[27] + 66 * flag[28] + 8 * flag[29] + 89 * flag[30] + 64 * flag[31] + 30 * flag[32] + 11 * flag[33] + 8 * flag[34] + 83 * flag[35] == 147899 and 51 * flag[0] + 94 * flag[1] + 58 * flag[2] + 76 * flag[3] + 21 * flag[4] + 10 * flag[5] + 75 * flag[6] + 4 * flag[7] + 55 * flag[8] + 37 * flag[9] + 71 * flag[10] + 97 * flag[11] + 27 * flag[12] + 93 * flag[13] + 82 * flag[14] + 94 * flag[15] + 38 * flag[16] + 69 * flag[17] + 36 * flag[18] + 58 * flag[19] + 93 * flag[20] + 18 * flag[21] + 54 * flag[22] + 59 * flag[23] + 12 * flag[24] + 12 * flag[25] + 54 * flag[26] + 83 * flag[27] + 73 * flag[28] + 83 * flag[29] + 33 * flag[30] + 12 * flag[31] + 78 * flag[32] + 38 * flag[33] + 45 * flag[34] + 57 * flag[35] == 176754 and 78 * flag[0] + 29 * flag[1] + 8 * flag[2] + 47 * flag[3] + 48 * flag[4] + 88 * flag[5] + 18 * flag[6] + 88 * flag[7] + 50 * flag[8] + 58 * flag[9] + 36 * flag[10] + 88 * flag[11] + 9 * flag[12] + 74 * flag[13] + 85 * flag[14] + 5 * flag[15] + 91 * flag[16] + 58 * flag[17] + 85 * flag[18] + 46 * flag[19] + 89 * flag[20] + 76 * flag[21] + 61 * flag[22] + 6 * flag[23] + 61 * flag[24] + 78 * flag[25] + 4 * flag[26] + 48 * flag[27] + 50 * flag[28] + 69 * flag[29] + 23 * flag[30] + 70 * flag[31] + 23 * flag[32] + 15 * flag[33] + 22 * flag[34] + 68 * flag[35] == 171970 and 75 * flag[0] + 2 * flag[1] + 94 * flag[2] + 97 * flag[3] + 72 * flag[4] + 62 * flag[5] + 78 * flag[6] + 42 * flag[7] + 69 * flag[8] + 11 * flag[9] + 37 * flag[10] + 3 * flag[11] + 29 * flag[12] + 15 * flag[13] + 39 * flag[14] + 33 * flag[15] + 18 * flag[16] + 33 * flag[17] + 12 * flag[18] + 64 * flag[19] + 6 * flag[20] + 18 * flag[21] + 34 * flag[22] + 15 * flag[23] + 3 * flag[24] + 100 * flag[25] + 85 * flag[26] + 32 * flag[27] + 97 * flag[28] + 93 * flag[29] + 84 * flag[30] + 73 * flag[31] + 26 * flag[32] + 31 * flag[33] + 71 * flag[34] + 97 * flag[35] == 166497 and 59 * flag[0] + 26 * flag[1] + 48 * flag[2] + 86 * flag[3] + 58 * flag[4] + 70 * flag[5] + 61 * flag[6] + 100 * flag[7] + 63 * flag[8] + 74 * flag[9] + 26 * flag[10] + 38 * flag[11] + 24 * flag[12] + 45 * flag[13] + 52 * flag[14] + 32 * flag[15] + 91 * flag[16] + 89 * flag[17] + 19 * flag[18] + 59 * flag[19] + 87 * flag[20] + 5 * flag[21] + 15 * flag[22] + 68 * flag[23] + 72 * flag[24] + 67 * flag[25] + 2 * flag[26] + 65 * flag[27] + 46 * flag[28] + 10 * flag[29] + 33 * flag[30] + 79 * flag[31] + 11 * flag[32] + 16 * flag[33] + 73 * flag[34] + 53 * flag[35] == 173887 and 6 * flag[0] + 66 * flag[1] + 59 * flag[2] + 76 * flag[3] + 86 * flag[4] + 20 * flag[5] + 59 * flag[6] + 34 * flag[7] + 28 * flag[8] + 48 * flag[9] + 86 * flag[10] + 5 * flag[11] + 87 * flag[12] + 13 * flag[13] + 95 * flag[14] + 87 * flag[15] + 65 * flag[16] + 35 * flag[17] + 58 * flag[18] + 10 * flag[19] + 98 * flag[20] + 100 * flag[21] + 4 * flag[22] + 78 * flag[23] + 66 * flag[24] + 57 * flag[25] + 34 * flag[26] + 86 * flag[27] + 62 * flag[28] + 36 * flag[29] + 92 * flag[30] + 28 * flag[31] + 3 * flag[32] + 24 * flag[33] + 49 * flag[34] + 28 * flag[35] == 173189 and 25 * flag[0] + 48 * flag[1] + 44 * flag[2] + 16 * flag[3] + 99 * flag[4] + 100 * flag[5] + 69 * flag[6] + 26 * flag[7] + 65 * flag[8] + 32 * flag[9] + 18 * flag[10] + 65 * flag[11] + 58 * flag[12] + 72 * flag[13] + 61 * flag[14] + 56 * flag[15] + 10 * flag[16] + 78 * flag[17] + 93 * flag[18] + 98 * flag[19] + 39 * flag[20] + 43 * flag[21] + 87 * flag[22] + 12 * flag[23] + 42 * flag[24] + 100 * flag[25] + 100 * flag[26] + 47 * flag[27] + 31 * flag[28] + 51 * flag[29] + 75 * flag[30] + 10 * flag[31] + 63 * flag[32] + 48 * flag[33] + 22 * flag[34] + 87 * flag[35] == 174138 and 61 * flag[0] + 13 * flag[1] + 100 * flag[2] + 59 * flag[3] + 31 * flag[4] + 9 * flag[5] + 28 * flag[6] + 7 * flag[7] + 27 * flag[8] + 63 * flag[9] + 11 * flag[10] + 57 * flag[11] + 95 * flag[12] + 79 * flag[13] + 21 * flag[14] + 30 * flag[15] + 60 * flag[16] + 81 * flag[17] + 43 * flag[18] + 32 * flag[19] + 30 * flag[20] + 34 * flag[21] + 80 * flag[22] + 53 * flag[23] + 28 * flag[24] + 39 * flag[25] + 74 * flag[26] + 21 * flag[27] + 18 * flag[28] + 92 * flag[29] + 73 * flag[30] + 60 * flag[31] + 21 * flag[32] + 69 * flag[33] + 76 * flag[34] + 84 * flag[35] == 157623 and 22 * flag[0] + 62 * flag[1] + 61 * flag[2] + 20 * flag[3] + 66 * flag[4] + 2 * flag[5] + 11 * flag[6] + 82 * flag[7] + 93 * flag[8] + 13 * flag[9] + 69 * flag[10] + 37 * flag[11] + 92 * flag[12] + 80 * flag[13] + 66 * flag[14] + 47 * flag[15] + 28 * flag[16] + 14 * flag[17] + 62 * flag[18] + 56 * flag[19] + 89 * flag[20] + 29 * flag[21] + 39 * flag[22] + 38 * flag[23] + 46 * flag[24] + 10 * flag[25] + 6 * flag[26] + 82 * flag[27] + 77 * flag[28] + 78 * flag[29] + 45 * flag[30] + 50 * flag[31] + 5 * flag[32] + 73 * flag[33] + 17 * flag[34] + 65 * flag[35] == 154943 and 5 * flag[0] + 84 * flag[1] + 83 * flag[2] + 77 * flag[3] + 76 * flag[4] + 60 * flag[5] + 20 * flag[6] + 48 * flag[7] + 53 * flag[8] + 14 * flag[9] + 98 * flag[10] + 50 * flag[11] + 37 * flag[12] + 15 * flag[13] + 31 * flag[14] + 69 * flag[15] + 55 * flag[16] + 37 * flag[17] + 64 * flag[18] + 35 * flag[19] + 26 * flag[20] + 20 * flag[21] + 18 * flag[22] + 67 * flag[23] + 50 * flag[24] + 57 * flag[25] + 60 * flag[26] + 71 * flag[27] + 4 * flag[28] + 35 * flag[29] + 23 * flag[30] + 52 * flag[31] + 11 * flag[32] + 15 * flag[33] + 83 * flag[34] + 51 * flag[35] == 156078 and 33 * flag[0] + 47 * flag[1] + 89 * flag[2] + 52 * flag[3] + 89 * flag[4] + 55 * flag[5] + 98 * flag[6] + 28 * flag[7] + 48 * flag[8] + 90 * flag[9] + 69 * flag[10] + 29 * flag[11] + 68 * flag[12] + 24 * flag[13] + 19 * flag[14] + 18 * flag[15] + 44 * flag[16] + 27 * flag[17] + 14 * flag[18] + 64 * flag[19] + 15 * flag[20] + 31 * flag[21] + 23 * flag[22] + 2 * flag[23] + 36 * flag[24] + 45 * flag[25] + 37 * flag[26] + 71 * flag[27] + 61 * flag[28] + 92 * flag[29] + 28 * flag[30] + 64 * flag[31] + 13 * flag[32] + 66 * flag[33] + 98 * flag[34] + 3 * flag[35] == 156158 and 80 * flag[0] + 88 * flag[1] + 68 * flag[2] + 66 * flag[3] + 46 * flag[4] + 75 * flag[5] + 32 * flag[6] + 19 * flag[7] + 36 * flag[8] + 83 * flag[9] + 63 * flag[10] + 86 * flag[11] + 79 * flag[12] + 30 * flag[13] + 61 * flag[14] + 50 * flag[15] + 100 * flag[16] + 52 * flag[17] + 66 * flag[18] + 30 * flag[19] + 20 * flag[20] + 97 * flag[21] + 45 * flag[22] + 46 * flag[23] + 38 * flag[24] + 21 * flag[25] + 32 * flag[26] + 79 * flag[27] + 68 * flag[28] + 43 * flag[29] + 65 * flag[30] + 47 * flag[31] + 86 * flag[32] + 30 * flag[33] + 74 * flag[34] + 18 * flag[35] == 181770 and 11 * flag[0] + 58 * flag[1] + 95 * flag[2] + 67 * flag[3] + 96 * flag[4] + 74 * flag[5] + 60 * flag[6] + 11 * flag[7] + 21 * flag[8] + 14 * flag[9] + 100 * flag[10] + 60 * flag[11] + 70 * flag[12] + 92 * flag[13] + 92 * flag[14] + 39 * flag[15] + 43 * flag[16] + 52 * flag[17] + 5 * flag[18] + 22 * flag[19] + 90 * flag[20] + 70 * flag[21] + 12 * flag[22] + 52 * flag[23] + 36 * flag[24] + 21 * flag[25] + 45 * flag[26] + 59 * flag[27] + 74 * flag[28] + 46 * flag[29] + 11 * flag[30] + 60 * flag[31] + 8 * flag[32] + 52 * flag[33] + 14 * flag[34] + 77 * flag[35] == 173577 and 57 * flag[0] + 37 * flag[1] + 94 * flag[2] + 43 * flag[3] + 53 * flag[4] + 55 * flag[5] + 7 * flag[6] + 83 * flag[7] + 91 * flag[8] + 61 * flag[9] + 86 * flag[10] + 6 * flag[11] + 44 * flag[12] + 87 * flag[13] + 61 * flag[14] + 92 * flag[15] + 24 * flag[16] + 74 * flag[17] + 100 * flag[18] + 22 * flag[19] + 12 * flag[20] + 68 * flag[21] + 19 * flag[22] + 88 * flag[23] + 81 * flag[24] + 83 * flag[25] + 70 * flag[26] + 39 * flag[27] + 30 * flag[28] + 82 * flag[29] + 30 * flag[30] + 35 * flag[31] + 55 * flag[32] + 18 * flag[33] + 27 * flag[34] + 80 * flag[35] == 180922 and 80 * flag[0] + 14 * flag[1] + 5 * flag[2] + 89 * flag[3] + 71 * flag[4] + 82 * flag[5] + 44 * flag[6] + 8 * flag[7] + 33 * flag[8] + 26 * flag[9] + 77 * flag[10] + 49 * flag[11] + 36 * flag[12] + 90 * flag[13] + 73 * flag[14] + 71 * flag[15] + 66 * flag[16] + 4 * flag[17] + 37 * flag[18] + 78 * flag[19] + 38 * flag[20] + 18 * flag[21] + 15 * flag[22] + 79 * flag[23] + 6 * flag[24] + 74 * flag[25] + 18 * flag[26] + 85 * flag[27] + 56 * flag[28] + 53 * flag[29] + 90 * flag[30] + 75 * flag[31] + 52 * flag[32] + 2 * flag[33] + 13 * flag[34] + 54 * flag[35] == 158596 and 96 * flag[0] + 29 * flag[1] + 37 * flag[2] + 70 * flag[3] + 92 * flag[4] + 80 * flag[5] + 24 * flag[6] + 36 * flag[7] + 32 * flag[8] + 29 * flag[9] + 78 * flag[10] + 45 * flag[11] + 58 * flag[12] + 55 * flag[13] + 16 * flag[14] + 92 * flag[15] + 71 * flag[16] + 82 * flag[17] + 86 * flag[18] + 23 * flag[19] + 4 * flag[20] + 58 * flag[21] + 16 * flag[22] + 18 * flag[23] + 38 * flag[24] + 53 * flag[25] + 82 * flag[26] + 76 * flag[27] + 83 * flag[28] + 73 * flag[29] + 87 * flag[30] + 36 * flag[31] + 61 * flag[32] + 85 * flag[33] + 61 * flag[34] + 69 * flag[35] == 181072 and 14 * flag[0] + 71 * flag[1] + 53 * flag[2] + 46 * flag[3] + 59 * flag[4] + 53 * flag[5] + 22 * flag[6] + 69 * flag[7] + 67 * flag[8] + 43 * flag[9] + 23 * flag[10] + 14 * flag[11] + 77 * flag[12] + 95 * flag[13] + 19 * flag[14] + 83 * flag[15] + 79 * flag[16] + 41 * flag[17] + 12 * flag[18] + 53 * flag[19] + 3 * flag[20] + 4 * flag[21] + 65 * flag[22] + 92 * flag[23] + 64 * flag[24] + 52 * flag[25] + 3 * flag[26] + 59 * flag[27] + 89 * flag[28] + 75 * flag[29] + 12 * flag[30] + 46 * flag[31] + 61 * flag[32] + 53 * flag[33] + 97 * flag[34] + 43 * flag[35] == 163777 and 57 * flag[0] + 99 * flag[1] + 49 * flag[2] + 100 * flag[3] + 68 * flag[4] + 99 * flag[5] + 26 * flag[6] + 65 * flag[7] + 47 * flag[8] + 65 * flag[9] + 90 * flag[10] + 68 * flag[11] + 84 * flag[12] + 4 * flag[13] + 9 * flag[14] + 43 * flag[15] + 88 * flag[16] + 33 * flag[17] + 48 * flag[18] + 88 * flag[19] + 37 * flag[20] + 31 * flag[21] + 21 * flag[22] + 94 * flag[23] + 22 * flag[24] + 93 * flag[25] + 70 * flag[26] + 14 * flag[27] + 13 * flag[28] + 28 * flag[29] + 83 * flag[30] + 12 * flag[31] + 80 * flag[32] + 58 * flag[33] + 43 * flag[34] + 97 * flag[35] == 187620 and 33 * flag[0] + 94 * flag[1] + 56 * flag[2] + 48 * flag[3] + 13 * flag[4] + 44 * flag[5] + 81 * flag[6] + 42 * flag[7] + 19 * flag[8] + 96 * flag[9] + 67 * flag[10] + 79 * flag[11] + 12 * flag[12] + 67 * flag[13] + 34 * flag[14] + 72 * flag[15] + 45 * flag[16] + 48 * flag[17] + 24 * flag[18] + 71 * flag[19] + 65 * flag[20] + 13 * flag[21] + 32 * flag[22] + 97 * flag[23] + 48 * flag[24] + 42 * flag[25] + 65 * flag[26] + 95 * flag[27] + 54 * flag[28] + 9 * flag[29] + 35 * flag[30] + 57 * flag[31] + 18 * flag[32] + 20 * flag[33] + 83 * flag[34] + 76 * flag[35] == 169266 and 31 * flag[0] + 38 * flag[1] + 83 * flag[2] + 45 * flag[3] + 28 * flag[4] + 97 * flag[5] + 54 * flag[6] + 11 * flag[7] + 80 * flag[8] + 45 * flag[9] + 92 * flag[10] + 13 * flag[11] + 52 * flag[12] + 94 * flag[13] + 51 * flag[14] + 30 * flag[15] + 11 * flag[16] + 61 * flag[17] + 46 * flag[18] + 10 * flag[19] + 28 * flag[20] + 72 * flag[21] + 20 * flag[22] + 95 * flag[23] + 90 * flag[24] + 39 * flag[25] + 32 * flag[26] + 95 * flag[27] + 19 * flag[28] + 3 * flag[29] + 65 * flag[30] + 71 * flag[31] + 73 * flag[32] + 80 * flag[33] + 23 * flag[34] + 71 * flag[35] == 162587 and 9 * flag[0] + 81 * flag[1] + 80 * flag[2] + 37 * flag[3] + 96 * flag[4] + 72 * flag[5] + 95 * flag[6] + 93 * flag[7] + 26 * flag[8] + 98 * flag[9] + 50 * flag[10] + 79 * flag[11] + 57 * flag[12] + 13 * flag[13] + 49 * flag[14] + 96 * flag[15] + 82 * flag[16] + 84 * flag[17] + 89 * flag[18] + 40 * flag[19] + 38 * flag[20] + 66 * flag[21] + 81 * flag[22] + 81 * flag[23] + 79 * flag[24] + 77 * flag[25] + 86 * flag[26] + 68 * flag[27] + 26 * flag[28] + 37 * flag[29] + 15 * flag[30] + 56 * flag[31] + 13 * flag[32] + 17 * flag[33] + 50 * flag[34] + 37 * flag[35] == 198705 and 82 * flag[0] + 57 * flag[1] + 33 * flag[2] + 32 * flag[3] + 79 * flag[4] + 25 * flag[5] + 54 * flag[6] + 27 * flag[7] + 50 * flag[8] + 14 * flag[9] + 72 * flag[10] + 31 * flag[11] + 28 * flag[12] + 66 * flag[13] + 4 * flag[14] + 6 * flag[15] + 48 * flag[16] + 34 * flag[17] + 63 * flag[18] + 51 * flag[19] + 12 * flag[20] + 21 * flag[21] + 73 * flag[22] + 66 * flag[23] + 53 * flag[24] + 38 * flag[25] + 54 * flag[26] + 59 * flag[27] + 76 * flag[28] + 63 * flag[29] + 61 * flag[30] + 30 * flag[31] + 84 * flag[32] + 80 * flag[33] + 98 * flag[34] + 46 * flag[35] == 160349 and 69 * flag[0] + 15 * flag[1] + 23 * flag[2] + 8 * flag[3] + 46 * flag[4] + 55 * flag[5] + 21 * flag[6] + 91 * flag[7] + 37 * flag[8] + 9 * flag[9] + 61 * flag[10] + 20 * flag[11] + 23 * flag[12] + 96 * flag[13] + 28 * flag[14] + 67 * flag[15] + 19 * flag[16] + 50 * flag[17] + 18 * flag[18] + 71 * flag[19] + 30 * flag[20] + 14 * flag[21] + 10 * flag[22] + 24 * flag[23] + 100 * flag[24] + 15 * flag[25] + 91 * flag[26] + 15 * flag[27] + 93 * flag[28] + 24 * flag[29] + 46 * flag[30] + 61 * flag[31] + 67 * flag[32] + 60 * flag[33] + 56 * flag[34] + 81 * flag[35] == 148095:
        return True


def main():
    flag = str(input('Input your flag: ')).encode()
    res = check(flag)
    if res:
        print('Right flag!')
        return None
    None('Wrong flag!')

if __name__ == '__main__':
    main()
    return None

条件判断，要这一堆东西满足好几个等式

了解一下z3求解

Z3 是微软研究院开发的一款高性能定理证明器（Theorem Prover），也被称为 SMT 求解器（Satisfiability Modulo Theories Solver）。

简单来说，它是一个可以自动求解约束条件的工具。

from z3 import *

flag = [Int(f"f{i}") for i in range(36)]
s = Solver()
for i in range(36): s.add(flag[i] >= 32, flag[i] <= 126)

s.add(
    47 * flag[0] + 41 * flag[1] + 32 * flag[2] + 56 * flag[3] + 52 * flag[4] + 67 * flag[5] + 13 * flag[6] + 25 * flag[7] + 20 * flag[8] +
    98 * flag[9] + 88 * flag[10] + 65 * flag[11] + 82 * flag[12] + 92 * flag[13] + 3 * flag[14] + 29 * flag[15] + 93 * flag[16] + 88 * flag[17] +
    45 * flag[18] + 58 * flag[19] + 40 * flag[20] + 72 * flag[21] + 99 * flag[22] + 10 * flag[23] + 94 * flag[24] + 62 * flag[25] + 82 * flag[26] +
    92 * flag[27] + 23 * flag[28] + 46 * flag[29] + 55 * flag[30] + 72 * flag[31] + 44 * flag[32] + 9 * flag[33] + 65 * flag[34] + 42 * flag[35]
    == 176386)

s.add(
    10 * flag[0] + 98 * flag[1] + 5 * flag[2] + 28 * flag[3] + 68 * flag[4] + 20 * flag[5] + 2 * flag[6] + 22 * flag[7] + 65 * flag[8] +
    44 * flag[9] + 85 * flag[10] + 97 * flag[11] + 33 * flag[12] + 74 * flag[13] + 93 * flag[14] + 74 * flag[15] + 41 * flag[16] + 65 * flag[17] +
    32 * flag[18] + 93 * flag[19] + 22 * flag[20] + 69 * flag[21] + 68 * flag[22] + 57 * flag[23] + 47 * flag[24] + 29 * flag[25] + 74 * flag[26] +
    54 * flag[27] + 91 * flag[28] + 90 * flag[29] + 26 * flag[30] + 11 * flag[31] + 89 * flag[32] + 57 * flag[33] + 100 * flag[34] + 95 * flag[35]
    == 186050)

s.add(
    25 * flag[0] + 22 * flag[1] + 54 * flag[2] + 5 * flag[3] + 8 * flag[4] + 3 * flag[5] + 12 * flag[6] + 70 * flag[7] + 25 * flag[8] +
    61 * flag[9] + 68 * flag[10] + 12 * flag[11] + 27 * flag[12] + 42 * flag[13] + 83 * flag[14] + 91 * flag[15] + 67 * flag[16] + 46 * flag[17] +
    8 * flag[18] + 45 * flag[19] + 94 * flag[20] + 80 * flag[21] + 69 * flag[22] + 95 * flag[23] + 12 * flag[24] + 21 * flag[25] + 94 * flag[26] +
    82 * flag[27] + 93 * flag[28] + 41 * flag[29] + 4 * flag[30] + 56 * flag[31] + 92 * flag[32] + 77 * flag[33] + 15 * flag[34] + 30 * flag[35]
    == 154690)

s.add(
    33 * flag[0] + 49 * flag[1] + 56 * flag[2] + 40 * flag[3] + 90 * flag[4] + 59 * flag[5] + 82 * flag[6] + 6 * flag[7] + 81 * flag[8] +
    32 * flag[9] + 23 * flag[10] + 76 * flag[11] + 93 * flag[12] + 83 * flag[13] + 10 * flag[14] + 44 * flag[15] + 58 * flag[16] + 33 * flag[17] +
    79 * flag[18] + 77 * flag[19] + 82 * flag[20] + 56 * flag[21] + 70 * flag[22] + 34 * flag[23] + 45 * flag[24] + 76 * flag[25] + 57 * flag[26] +
    43 * flag[27] + 100 * flag[28] + 19 * flag[29] + 11 * flag[30] + 90 * flag[31] + 3 * flag[32] + 60 * flag[33] + 57 * flag[34] + 23 * flag[35]
    == 172116)

s.add(
    65 * flag[0] + 70 * flag[1] + 20 * flag[2] + 32 * flag[3] + 75 * flag[4] + 30 * flag[5] + 3 * flag[6] + 78 * flag[7] + 35 * flag[8] +
    45 * flag[9] + 95 * flag[10] + 93 * flag[11] + 52 * flag[12] + 32 * flag[13] + 88 * flag[14] + 94 * flag[15] + 67 * flag[16] + 34 * flag[17] +
    91 * flag[18] + 88 * flag[19] + 31 * flag[20] + 61 * flag[21] + 17 * flag[22] + 99 * flag[23] + 100 * flag[24] + 49 * flag[25] + 4 * flag[26] +
    60 * flag[27] + 81 * flag[28] + 88 * flag[29] + 43 * flag[30] + 34 * flag[31] + 30 * flag[32] + 52 * flag[33] + 18 * flag[34] + 100 * flag[35]
    == 190544)

s.add(
    81 * flag[0] + 42 * flag[1] + 28 * flag[2] + 98 * flag[3] + 31 * flag[4] + 46 * flag[5] + 64 * flag[6] + 15 * flag[7] + 49 * flag[8] +
    13 * flag[9] + 100 * flag[10] + 81 * flag[11] + 32 * flag[12] + 52 * flag[13] + 59 * flag[14] + 24 * flag[15] + 94 * flag[16] + 32 * flag[17] +
    93 * flag[18] + 32 * flag[19] + 13 * flag[20] + 89 * flag[21] + 37 * flag[22] + 30 * flag[23] + 78 * flag[24] + 81 * flag[25] + 9 * flag[26] +
    45 * flag[27] + 93 * flag[28] + 100 * flag[29] + 97 * flag[30] + 10 * flag[31] + 80 * flag[32] + 54 * flag[33] + 88 * flag[34] + 85 * flag[35]
    == 190323)

s.add(
    76 * flag[0] + 54 * flag[1] + 5 * flag[2] + 14 * flag[3] + 62 * flag[4] + 44 * flag[5] + 24 * flag[6] + 29 * flag[7] + 85 * flag[8] +
    87 * flag[9] + 19 * flag[10] + 3 * flag[11] + 65 * flag[12] + 24 * flag[13] + 92 * flag[14] + 37 * flag[15] + 57 * flag[16] + 20 * flag[17] +
    45 * flag[18] + 5 * flag[19] + 13 * flag[20] + 91 * flag[21] + 92 * flag[22] + 75 * flag[23] + 36 * flag[24] + 79 * flag[25] + 12 * flag[26] +
    22 * flag[27] + 75 * flag[28] + 82 * flag[29] + 28 * flag[30] + 82 * flag[31] + 24 * flag[32] + 53 * flag[33] + 56 * flag[34] + 92 * flag[35]
    == 162017)

s.add(
    53 * flag[0] + 52 * flag[1] + 72 * flag[2] + 23 * flag[3] + 26 * flag[4] + 13 * flag[5] + 62 * flag[6] + 96 * flag[7] + 67 * flag[8] +
    96 * flag[9] + 66 * flag[10] + 41 * flag[11] + 5 * flag[12] + 18 * flag[13] + 37 * flag[14] + 13 * flag[15] + 61 * flag[16] + 71 * flag[17] +
    91 * flag[18] + 96 * flag[19] + 56 * flag[20] + 3 * flag[21] + 65 * flag[22] + 14 * flag[23] + 57 * flag[24] + 69 * flag[25] + 75 * flag[26] +
    68 * flag[27] + 10 * flag[28] + 60 * flag[29] + 62 * flag[30] + 95 * flag[31] + 53 * flag[32] + 19 * flag[33] + 7 * flag[34] + 56 * flag[35]
    == 165118)

s.add(
    26 * flag[0] + 7 * flag[1] + 49 * flag[2] + 14 * flag[3] + 36 * flag[4] + 87 * flag[5] + 21 * flag[6] + 35 * flag[7] + 15 * flag[8] +
    91 * flag[9] + 15 * flag[10] + 100 * flag[11] + 8 * flag[12] + 32 * flag[13] + 100 * flag[14] + 35 * flag[15] + 66 * flag[16] + 3 * flag[17] +
    79 * flag[18] + 96 * flag[19] + 82 * flag[20] + 95 * flag[21] + 68 * flag[22] + 13 * flag[23] + 86 * flag[24] + 51 * flag[25] + 24 * flag[26] +
    76 * flag[27] + 30 * flag[28] + 60 * flag[29] + 29 * flag[30] + 70 * flag[31] + 40 * flag[32] + 90 * flag[33] + 44 * flag[34] + 3 * flag[35]
    == 153332)

s.add(
    47 * flag[0] + 19 * flag[1] + 37 * flag[2] + 93 * flag[3] + 73 * flag[4] + 30 * flag[5] + 45 * flag[6] + 47 * flag[7] + 72 * flag[8] +
    85 * flag[9] + 37 * flag[10] + 68 * flag[11] + 89 * flag[12] + 34 * flag[13] + 4 * flag[14] + 50 * flag[15] + 87 * flag[16] + 33 * flag[17] +
    87 * flag[18] + 43 * flag[19] + 9 * flag[20] + 61 * flag[21] + 93 * flag[22] + 49 * flag[23] + 74 * flag[24] + 49 * flag[25] + 68 * flag[26] +
    29 * flag[27] + 54 * flag[28] + 54 * flag[29] + 37 * flag[30] + 79 * flag[31] + 33 * flag[32] + 65 * flag[33] + 59 * flag[34] + 15 * flag[35]
    == 168472)

s.add(
    79 * flag[0] + 73 * flag[1] + 60 * flag[2] + 62 * flag[3] + 25 * flag[4] + 16 * flag[5] + 77 * flag[6] + 81 * flag[7] + 79 * flag[8] +
    31 * flag[9] + 82 * flag[10] + 84 * flag[11] + 62 * flag[12] + 36 * flag[13] + 18 * flag[14] + 20 * flag[15] + 46 * flag[16] + 57 * flag[17] +
    21 * flag[18] + 40 * flag[19] + 3 * flag[20] + 50 * flag[21] + 58 * flag[22] + 80 * flag[23] + 84 * flag[24] + 71 * flag[25] + 87 * flag[26] +
    3 * flag[27] + 13 * flag[28] + 77 * flag[29] + 83 * flag[30] + 39 * flag[31] + 55 * flag[32] + 34 * flag[33] + 41 * flag[34] + 63 * flag[35]
    == 178706)

s.add(
    7 * flag[0] + 50 * flag[1] + 26 * flag[2] + 79 * flag[3] + 21 * flag[4] + 42 * flag[5] + 83 * flag[6] + 94 * flag[7] + 63 * flag[8] +
    83 * flag[9] + 3 * flag[10] + 68 * flag[11] + 25 * flag[12] + 91 * flag[13] + 3 * flag[14] + 5 * flag[15] + 17 * flag[16] + 61 * flag[17] +
    3 * flag[18] + 40 * flag[19] + 87 * flag[20] + 11 * flag[21] + 27 * flag[22] + 74 * flag[23] + 73 * flag[24] + 21 * flag[25] + 56 * flag[26] +
    46 * flag[27] + 36 * flag[28] + 24 * flag[29] + 14 * flag[30] + 63 * flag[31] + 21 * flag[32] + 71 * flag[33] + 30 * flag[34] + 53 * flag[35]
    == 143852)

s.add(
    57 * flag[0] + 51 * flag[1] + 49 * flag[2] + 15 * flag[3] + 94 * flag[4] + 34 * flag[5] + 27 * flag[6] + 5 * flag[7] + 100 * flag[8] +
    68 * flag[9] + 67 * flag[10] + 81 * flag[11] + 10 * flag[12] + 5 * flag[13] + 85 * flag[14] + 70 * flag[15] + 80 * flag[16] + 20 * flag[17] +
    89 * flag[18] + 30 * flag[19] + 84 * flag[20] + 35 * flag[21] + 41 * flag[22] + 87 * flag[23] + 75 * flag[24] + 67 * flag[25] + 20 * flag[26] +
    33 * flag[27] + 29 * flag[28] + 6 * flag[29] + 97 * flag[30] + 25 * flag[31] + 10 * flag[32] + 18 * flag[33] + 23 * flag[34] + 30 * flag[35]
    == 154052)

s.add(
    97 * flag[0] + 93 * flag[1] + 10 * flag[2] + 44 * flag[3] + 28 * flag[4] + 22 * flag[5] + 17 * flag[6] + 41 * flag[7] + 47 * flag[8] +
    62 * flag[9] + 42 * flag[10] + 47 * flag[11] + 61 * flag[12] + 32 * flag[13] + 31 * flag[14] + 52 * flag[15] + 47 * flag[16] + 92 * flag[17] +
    42 * flag[18] + 37 * flag[19] + 7 * flag[20] + 40 * flag[21] + 48 * flag[22] + 40 * flag[23] + 11 * flag[24] + 96 * flag[25] + 51 * flag[26] +
    42 * flag[27] + 66 * flag[28] + 8 * flag[29] + 89 * flag[30] + 64 * flag[31] + 30 * flag[32] + 11 * flag[33] + 8 * flag[34] + 83 * flag[35]
    == 147899)

s.add(
    51 * flag[0] + 94 * flag[1] + 58 * flag[2] + 76 * flag[3] + 21 * flag[4] + 10 * flag[5] + 75 * flag[6] + 4 * flag[7] + 55 * flag[8] +
    37 * flag[9] + 71 * flag[10] + 97 * flag[11] + 27 * flag[12] + 93 * flag[13] + 82 * flag[14] + 94 * flag[15] + 38 * flag[16] + 69 * flag[17] +
    36 * flag[18] + 58 * flag[19] + 93 * flag[20] + 18 * flag[21] + 54 * flag[22] + 59 * flag[23] + 12 * flag[24] + 12 * flag[25] + 54 * flag[26] +
    83 * flag[27] + 73 * flag[28] + 83 * flag[29] + 33 * flag[30] + 12 * flag[31] + 78 * flag[32] + 38 * flag[33] + 45 * flag[34] + 57 * flag[35]
    == 176754)

s.add(
    78 * flag[0] + 29 * flag[1] + 8 * flag[2] + 47 * flag[3] + 48 * flag[4] + 88 * flag[5] + 18 * flag[6] + 88 * flag[7] + 50 * flag[8] +
    58 * flag[9] + 36 * flag[10] + 88 * flag[11] + 9 * flag[12] + 74 * flag[13] + 85 * flag[14] + 5 * flag[15] + 91 * flag[16] + 58 * flag[17] +
    85 * flag[18] + 46 * flag[19] + 89 * flag[20] + 76 * flag[21] + 61 * flag[22] + 6 * flag[23] + 61 * flag[24] + 78 * flag[25] + 4 * flag[26] +
    48 * flag[27] + 50 * flag[28] + 69 * flag[29] + 23 * flag[30] + 70 * flag[31] + 23 * flag[32] + 15 * flag[33] + 22 * flag[34] + 68 * flag[35]
    == 171970)

s.add(
    75 * flag[0] + 2 * flag[1] + 94 * flag[2] + 97 * flag[3] + 72 * flag[4] + 62 * flag[5] + 78 * flag[6] + 42 * flag[7] + 69 * flag[8] +
    11 * flag[9] + 37 * flag[10] + 3 * flag[11] + 29 * flag[12] + 15 * flag[13] + 39 * flag[14] + 33 * flag[15] + 18 * flag[16] + 33 * flag[17] +
    12 * flag[18] + 64 * flag[19] + 6 * flag[20] + 18 * flag[21] + 34 * flag[22] + 15 * flag[23] + 3 * flag[24] + 100 * flag[25] + 85 * flag[26] +
    32 * flag[27] + 97 * flag[28] + 93 * flag[29] + 84 * flag[30] + 73 * flag[31] + 26 * flag[32] + 31 * flag[33] + 71 * flag[34] + 97 * flag[35]
    == 166497)

s.add(
    59 * flag[0] + 26 * flag[1] + 48 * flag[2] + 86 * flag[3] + 58 * flag[4] + 70 * flag[5] + 61 * flag[6] + 100 * flag[7] + 63 * flag[8] +
    74 * flag[9] + 26 * flag[10] + 38 * flag[11] + 24 * flag[12] + 45 * flag[13] + 52 * flag[14] + 32 * flag[15] + 91 * flag[16] + 89 * flag[17] +
    19 * flag[18] + 59 * flag[19] + 87 * flag[20] + 5 * flag[21] + 15 * flag[22] + 68 * flag[23] + 72 * flag[24] + 67 * flag[25] + 2 * flag[26] +
    65 * flag[27] + 46 * flag[28] + 10 * flag[29] + 33 * flag[30] + 79 * flag[31] + 11 * flag[32] + 16 * flag[33] + 73 * flag[34] + 53 * flag[35]
    == 173887)

s.add(
    6 * flag[0] + 66 * flag[1] + 59 * flag[2] + 76 * flag[3] + 86 * flag[4] + 20 * flag[5] + 59 * flag[6] + 34 * flag[7] + 28 * flag[8] +
    48 * flag[9] + 86 * flag[10] + 5 * flag[11] + 87 * flag[12] + 13 * flag[13] + 95 * flag[14] + 87 * flag[15] + 65 * flag[16] + 35 * flag[17] +
    58 * flag[18] + 10 * flag[19] + 98 * flag[20] + 100 * flag[21] + 4 * flag[22] + 78 * flag[23] + 66 * flag[24] + 57 * flag[25] + 34 * flag[26] +
    86 * flag[27] + 62 * flag[28] + 36 * flag[29] + 92 * flag[30] + 28 * flag[31] + 3 * flag[32] + 24 * flag[33] + 49 * flag[34] + 28 * flag[35]
    == 173189)

s.add(
    25 * flag[0] + 48 * flag[1] + 44 * flag[2] + 16 * flag[3] + 99 * flag[4] + 100 * flag[5] + 69 * flag[6] + 26 * flag[7] + 65 * flag[8] +
    32 * flag[9] + 18 * flag[10] + 65 * flag[11] + 58 * flag[12] + 72 * flag[13] + 61 * flag[14] + 56 * flag[15] + 10 * flag[16] + 78 * flag[17] +
    93 * flag[18] + 98 * flag[19] + 39 * flag[20] + 43 * flag[21] + 87 * flag[22] + 12 * flag[23] + 42 * flag[24] + 100 * flag[25] + 100 * flag[26] +
    47 * flag[27] + 31 * flag[28] + 51 * flag[29] + 75 * flag[30] + 10 * flag[31] + 63 * flag[32] + 48 * flag[33] + 22 * flag[34] + 87 * flag[35]
    == 174138)

s.add(
    61 * flag[0] + 13 * flag[1] + 100 * flag[2] + 59 * flag[3] + 31 * flag[4] + 9 * flag[5] + 28 * flag[6] + 7 * flag[7] + 27 * flag[8] +
    63 * flag[9] + 11 * flag[10] + 57 * flag[11] + 95 * flag[12] + 79 * flag[13] + 21 * flag[14] + 30 * flag[15] + 60 * flag[16] + 81 * flag[17] +
    43 * flag[18] + 32 * flag[19] + 30 * flag[20] + 34 * flag[21] + 80 * flag[22] + 53 * flag[23] + 28 * flag[24] + 39 * flag[25] + 74 * flag[26] +
    21 * flag[27] + 18 * flag[28] + 92 * flag[29] + 73 * flag[30] + 60 * flag[31] + 21 * flag[32] + 69 * flag[33] + 76 * flag[34] + 84 * flag[35]
    == 157623)

s.add(
    22 * flag[0] + 62 * flag[1] + 61 * flag[2] + 20 * flag[3] + 66 * flag[4] + 2 * flag[5] + 11 * flag[6] + 82 * flag[7] + 93 * flag[8] +
    13 * flag[9] + 69 * flag[10] + 37 * flag[11] + 92 * flag[12] + 80 * flag[13] + 66 * flag[14] + 47 * flag[15] + 28 * flag[16] + 14 * flag[17] +
    62 * flag[18] + 56 * flag[19] + 89 * flag[20] + 29 * flag[21] + 39 * flag[22] + 38 * flag[23] + 46 * flag[24] + 10 * flag[25] + 6 * flag[26] +
    82 * flag[27] + 77 * flag[28] + 78 * flag[29] + 45 * flag[30] + 50 * flag[31] + 5 * flag[32] + 73 * flag[33] + 17 * flag[34] + 65 * flag[35]
    == 154943)

s.add(
    5 * flag[0] + 84 * flag[1] + 83 * flag[2] + 77 * flag[3] + 76 * flag[4] + 60 * flag[5] + 20 * flag[6] + 48 * flag[7] + 53 * flag[8] +
    14 * flag[9] + 98 * flag[10] + 50 * flag[11] + 37 * flag[12] + 15 * flag[13] + 31 * flag[14] + 69 * flag[15] + 55 * flag[16] + 37 * flag[17] +
    64 * flag[18] + 35 * flag[19] + 26 * flag[20] + 20 * flag[21] + 18 * flag[22] + 67 * flag[23] + 50 * flag[24] + 57 * flag[25] + 60 * flag[26] +
    71 * flag[27] + 4 * flag[28] + 35 * flag[29] + 23 * flag[30] + 52 * flag[31] + 11 * flag[32] + 15 * flag[33] + 83 * flag[34] + 51 * flag[35]
    == 156078)

s.add(
    33 * flag[0] + 47 * flag[1] + 89 * flag[2] + 52 * flag[3] + 89 * flag[4] + 55 * flag[5] + 98 * flag[6] + 28 * flag[7] + 48 * flag[8] +
    90 * flag[9] + 69 * flag[10] + 29 * flag[11] + 68 * flag[12] + 24 * flag[13] + 19 * flag[14] + 18 * flag[15] + 44 * flag[16] + 27 * flag[17] +
    14 * flag[18] + 64 * flag[19] + 15 * flag[20] + 31 * flag[21] + 23 * flag[22] + 2 * flag[23] + 36 * flag[24] + 45 * flag[25] + 37 * flag[26] +
    71 * flag[27] + 61 * flag[28] + 92 * flag[29] + 28 * flag[30] + 64 * flag[31] + 13 * flag[32] + 66 * flag[33] + 98 * flag[34] + 3 * flag[35]
    == 156158)

s.add(
    80 * flag[0] + 88 * flag[1] + 68 * flag[2] + 66 * flag[3] + 46 * flag[4] + 75 * flag[5] + 32 * flag[6] + 19 * flag[7] + 36 * flag[8] +
    83 * flag[9] + 63 * flag[10] + 86 * flag[11] + 79 * flag[12] + 30 * flag[13] + 61 * flag[14] + 50 * flag[15] + 100 * flag[16] + 52 * flag[17] +
    66 * flag[18] + 30 * flag[19] + 20 * flag[20] + 97 * flag[21] + 45 * flag[22] + 46 * flag[23] + 38 * flag[24] + 21 * flag[25] + 32 * flag[26] +
    79 * flag[27] + 68 * flag[28] + 43 * flag[29] + 65 * flag[30] + 47 * flag[31] + 86 * flag[32] + 30 * flag[33] + 74 * flag[34] + 18 * flag[35]
    == 181770)

s.add(
    11 * flag[0] + 58 * flag[1] + 95 * flag[2] + 67 * flag[3] + 96 * flag[4] + 74 * flag[5] + 60 * flag[6] + 11 * flag[7] + 21 * flag[8] +
    14 * flag[9] + 100 * flag[10] + 60 * flag[11] + 70 * flag[12] + 92 * flag[13] + 92 * flag[14] + 39 * flag[15] + 43 * flag[16] + 52 * flag[17] +
    5 * flag[18] + 22 * flag[19] + 90 * flag[20] + 70 * flag[21] + 12 * flag[22] + 52 * flag[23] + 36 * flag[24] + 21 * flag[25] + 45 * flag[26] +
    59 * flag[27] + 74 * flag[28] + 46 * flag[29] + 11 * flag[30] + 60 * flag[31] + 8 * flag[32] + 52 * flag[33] + 14 * flag[34] + 77 * flag[35]
    == 173577)

s.add(
    57 * flag[0] + 37 * flag[1] + 94 * flag[2] + 43 * flag[3] + 53 * flag[4] + 55 * flag[5] + 7 * flag[6] + 83 * flag[7] + 91 * flag[8] +
    61 * flag[9] + 86 * flag[10] + 6 * flag[11] + 44 * flag[12] + 87 * flag[13] + 61 * flag[14] + 92 * flag[15] + 24 * flag[16] + 74 * flag[17] +
    100 * flag[18] + 22 * flag[19] + 12 * flag[20] + 68 * flag[21] + 19 * flag[22] + 88 * flag[23] + 81 * flag[24] + 83 * flag[25] + 70 * flag[26] +
    39 * flag[27] + 30 * flag[28] + 82 * flag[29] + 30 * flag[30] + 35 * flag[31] + 55 * flag[32] + 18 * flag[33] + 27 * flag[34] + 80 * flag[35]
    == 180922)

s.add(
    80 * flag[0] + 14 * flag[1] + 5 * flag[2] + 89 * flag[3] + 71 * flag[4] + 82 * flag[5] + 44 * flag[6] + 8 * flag[7] + 33 * flag[8] +
    26 * flag[9] + 77 * flag[10] + 49 * flag[11] + 36 * flag[12] + 90 * flag[13] + 73 * flag[14] + 71 * flag[15] + 66 * flag[16] + 4 * flag[17] +
    37 * flag[18] + 78 * flag[19] + 38 * flag[20] + 18 * flag[21] + 15 * flag[22] + 79 * flag[23] + 6 * flag[24] + 74 * flag[25] + 18 * flag[26] +
    85 * flag[27] + 56 * flag[28] + 53 * flag[29] + 90 * flag[30] + 75 * flag[31] + 52 * flag[32] + 2 * flag[33] + 13 * flag[34] + 54 * flag[35]
    == 158596)

s.add(
    96 * flag[0] + 29 * flag[1] + 37 * flag[2] + 70 * flag[3] + 92 * flag[4] + 80 * flag[5] + 24 * flag[6] + 36 * flag[7] + 32 * flag[8] +
    29 * flag[9] + 78 * flag[10] + 45 * flag[11] + 58 * flag[12] + 55 * flag[13] + 16 * flag[14] + 92 * flag[15] + 71 * flag[16] + 82 * flag[17] +
    86 * flag[18] + 23 * flag[19] + 4 * flag[20] + 58 * flag[21] + 16 * flag[22] + 18 * flag[23] + 38 * flag[24] + 53 * flag[25] + 82 * flag[26] +
    76 * flag[27] + 83 * flag[28] + 73 * flag[29] + 87 * flag[30] + 36 * flag[31] + 61 * flag[32] + 85 * flag[33] + 61 * flag[34] + 69 * flag[35]
    == 181072)

s.add(
    14 * flag[0] + 71 * flag[1] + 53 * flag[2] + 46 * flag[3] + 59 * flag[4] + 53 * flag[5] + 22 * flag[6] + 69 * flag[7] + 67 * flag[8] +
    43 * flag[9] + 23 * flag[10] + 14 * flag[11] + 77 * flag[12] + 95 * flag[13] + 19 * flag[14] + 83 * flag[15] + 79 * flag[16] + 41 * flag[17] +
    12 * flag[18] + 53 * flag[19] + 3 * flag[20] + 4 * flag[21] + 65 * flag[22] + 92 * flag[23] + 64 * flag[24] + 52 * flag[25] + 3 * flag[26] +
    59 * flag[27] + 89 * flag[28] + 75 * flag[29] + 12 * flag[30] + 46 * flag[31] + 61 * flag[32] + 53 * flag[33] + 97 * flag[34] + 43 * flag[35]
    == 163777)

s.add(
    57 * flag[0] + 99 * flag[1] + 49 * flag[2] + 100 * flag[3] + 68 * flag[4] + 99 * flag[5] + 26 * flag[6] + 65 * flag[7] + 47 * flag[8] +
    65 * flag[9] + 90 * flag[10] + 68 * flag[11] + 84 * flag[12] + 4 * flag[13] + 9 * flag[14] + 43 * flag[15] + 88 * flag[16] + 33 * flag[17] +
    48 * flag[18] + 88 * flag[19] + 37 * flag[20] + 31 * flag[21] + 21 * flag[22] + 94 * flag[23] + 22 * flag[24] + 93 * flag[25] + 70 * flag[26] +
    14 * flag[27] + 13 * flag[28] + 28 * flag[29] + 83 * flag[30] + 12 * flag[31] + 80 * flag[32] + 58 * flag[33] + 43 * flag[34] + 97 * flag[35]
    == 187620)

s.add(
    33 * flag[0] + 94 * flag[1] + 56 * flag[2] + 48 * flag[3] + 13 * flag[4] + 44 * flag[5] + 81 * flag[6] + 42 * flag[7] + 19 * flag[8] +
    96 * flag[9] + 67 * flag[10] + 79 * flag[11] + 12 * flag[12] + 67 * flag[13] + 34 * flag[14] + 72 * flag[15] + 45 * flag[16] + 48 * flag[17] +
    24 * flag[18] + 71 * flag[19] + 65 * flag[20] + 13 * flag[21] + 32 * flag[22] + 97 * flag[23] + 48 * flag[24] + 42 * flag[25] + 65 * flag[26] +
    95 * flag[27] + 54 * flag[28] + 9 * flag[29] + 35 * flag[30] + 57 * flag[31] + 18 * flag[32] + 20 * flag[33] + 83 * flag[34] + 76 * flag[35]
    == 169266)

s.add(
    31 * flag[0] + 38 * flag[1] + 83 * flag[2] + 45 * flag[3] + 28 * flag[4] + 97 * flag[5] + 54 * flag[6] + 11 * flag[7] + 80 * flag[8] +
    45 * flag[9] + 92 * flag[10] + 13 * flag[11] + 52 * flag[12] + 94 * flag[13] + 51 * flag[14] + 30 * flag[15] + 11 * flag[16] + 61 * flag[17] +
    46 * flag[18] + 10 * flag[19] + 28 * flag[20] + 72 * flag[21] + 20 * flag[22] + 95 * flag[23] + 90 * flag[24] + 39 * flag[25] + 32 * flag[26] +
    95 * flag[27] + 19 * flag[28] + 3 * flag[29] + 65 * flag[30] + 71 * flag[31] + 73 * flag[32] + 80 * flag[33] + 23 * flag[34] + 71 * flag[35]
    == 162587)

s.add(
    9 * flag[0] + 81 * flag[1] + 80 * flag[2] + 37 * flag[3] + 96 * flag[4] + 72 * flag[5] + 95 * flag[6] + 93 * flag[7] + 26 * flag[8] +
    98 * flag[9] + 50 * flag[10] + 79 * flag[11] + 57 * flag[12] + 13 * flag[13] + 49 * flag[14] + 96 * flag[15] + 82 * flag[16] + 84 * flag[17] +
    89 * flag[18] + 40 * flag[19] + 38 * flag[20] + 66 * flag[21] + 81 * flag[22] + 81 * flag[23] + 79 * flag[24] + 77 * flag[25] + 86 * flag[26] +
    68 * flag[27] + 26 * flag[28] + 37 * flag[29] + 15 * flag[30] + 56 * flag[31] + 13 * flag[32] + 17 * flag[33] + 50 * flag[34] + 37 * flag[35]
    == 198705)

s.add(
    82 * flag[0] + 57 * flag[1] + 33 * flag[2] + 32 * flag[3] + 79 * flag[4] + 25 * flag[5] + 54 * flag[6] + 27 * flag[7] + 50 * flag[8] +
    14 * flag[9] + 72 * flag[10] + 31 * flag[11] + 28 * flag[12] + 66 * flag[13] + 4 * flag[14] + 6 * flag[15] + 48 * flag[16] + 34 * flag[17] +
    63 * flag[18] + 51 * flag[19] + 12 * flag[20] + 21 * flag[21] + 73 * flag[22] + 66 * flag[23] + 53 * flag[24] + 38 * flag[25] + 54 * flag[26] +
    59 * flag[27] + 76 * flag[28] + 63 * flag[29] + 61 * flag[30] + 30 * flag[31] + 84 * flag[32] + 80 * flag[33] + 98 * flag[34] + 46 * flag[35]
    == 160349)

s.add(
    69 * flag[0] + 15 * flag[1] + 23 * flag[2] + 8 * flag[3] + 46 * flag[4] + 55 * flag[5] + 21 * flag[6] + 91 * flag[7] + 37 * flag[8] +
    9 * flag[9] + 61 * flag[10] + 20 * flag[11] + 23 * flag[12] + 96 * flag[13] + 28 * flag[14] + 67 * flag[15] + 19 * flag[16] + 50 * flag[17] +
    18 * flag[18] + 71 * flag[19] + 30 * flag[20] + 14 * flag[21] + 10 * flag[22] + 24 * flag[23] + 100 * flag[24] + 15 * flag[25] + 91 * flag[26] +
    15 * flag[27] + 93 * flag[28] + 24 * flag[29] + 46 * flag[30] + 61 * flag[31] + 67 * flag[32] + 60 * flag[33] + 56 * flag[34] + 81 * flag[35]
    == 148095)


result = s.check() #验证是否有解，sat或unsat
print(result)
if result == sat:
    m = s.model() #提取结果
    chars = []
    for i in range(36):
        val = m[flag[i]].as_long() #.as_long() 是把 Z3 内部格式转成普通整数
        chars.append(chr(val))
    print("".join(chars))

flag{PytH0n_R3v3rs1Ng_4nd_Z3_s0lV3r}
posted @ 2026-07-03 10:17  E73RN4L  阅读(0)  评论(0)    收藏  举报