VishwaCTF 2026 wp
本文解析 VishwaCTF 2026 Writeup,涵盖迷宫路径 BFS 编码、LCG 参数恢复及 APK 逆向。核心利用 Base58 解码 ISO 隐藏数据、堆快照提取内存 Flag 及 Apache Syncope Keymaster 参数 XXE 漏洞。揭示了多种 CTF 题型中从静态分
Cryptography
PROCEDURAL LABYRINTH
核心分两步:
- 解出从入口到出口的唯一路径
- 把这条路径转成 bit 流,再还原成 ASCII
迷宫字符只有:
#:墙.:路>:入口<:出口
这种图最自然的做法就是把可走点当成图上的节点,跑 BFS / DFS 找路。
实际把路解出来后,会发现这题的“journey”不是让你看上下移动,而是看整条路径中的左右移动序列:
- 向右
R记作0 - 向左
L记作1 - 上下移动不参与编码
把这些左右移动抽出来以后,bit 流已经很像可打印文本了。
再注意一下入口处有一个“进入迷宫”的前导水平移动,它不属于正文,因此跳过第一个水平 bit,后面每 8 位转一个字节即可。
最后直接得到 flag。
文件前面几行是说明文字,真正的迷宫区是 701 行、每行 51 列的 # . > < 字符矩阵。
所以脚本里只要把满足:
- 字符集合属于
# . > < - 行长一致
的部分提取出来即可。
把所有可走字符:
.><
都视为 walkable。
然后从 > 开始 BFS,到 < 停止,并通过 prev 数组回溯整条路径。
拿到路径后,逐步比较相邻两点:
dc = +1,说明向右:记0dc = -1,说明向左:记1dr = ±1,上下移动:忽略
这样能得到一长串二进制位。
然后:
- 跳过开头 1 位(入口前导位)
- 每 8 位转成一个 ASCII 字符
- 可直接读出
VishwaCTF{...}
exp:
from collections import deque
import sys
def load_grid(path: str):
with open(path, "r", encoding="utf-8") as f:
lines = [line.rstrip("\n") for line in f]
grid = []
width = None
for line in lines:
if not line:
continue
if set(line) <= set("#.><"):
if width is None:
width = len(line)
if len(line) == width:
grid.append(line)
if not grid:
raise ValueError("No maze grid found.")
return grid
def find_points(grid):
start = end = None
for r, row in enumerate(grid):
for c, ch in enumerate(row):
if ch == ">":
start = (r, c)
elif ch == "<":
end = (r, c)
if start is None or end is None:
raise ValueError("Start or end marker not found.")
return start, end
def bfs_path(grid, start, end):
R, C = len(grid), len(grid[0])
walkable = {".", ">", "<"}
q = deque([start])
prev = {start: None}
for_pos = [(1, 0), (-1, 0), (0, 1), (0, -1)]
while q:
r, c = q.popleft()
if (r, c) == end:
break
for dr, dc in for_pos:
nr, nc = r + dr, c + dc
if 0 <= nr < R and 0 <= nc < C:
if grid[nr][nc] in walkable and (nr, nc) not in prev:
prev[(nr, nc)] = (r, c)
q.append((nr, nc))
if end not in prev:
raise ValueError("No path found from start to end.")
path = []
cur = end
while cur is not None:
path.append(cur)
cur = prev[cur]
path.reverse()
return path
def decode_from_path(path):
bits = []
for (r1, c1), (r2, c2) in zip(path, path[1:]):
dc = c2 - c1
# Only horizontal moves encode data
if dc == 1:
bits.append("0") # move right
elif dc == -1:
bits.append("1") # move left
bitstream = "".join(bits)
# Skip the first horizontal bit: it's just the entry step into the maze
bitstream = bitstream[1:]
out = []
for i in range(0, len(bitstream) - 7, 8):
byte = bitstream[i:i + 8]
ch = chr(int(byte, 2))
out.append(ch)
return "".join(out)
def main():
if len(sys.argv) != 2:
print(f"Usage: python {sys.argv[0]} maze.txt")
sys.exit(1)
grid = load_grid(sys.argv[1])
start, end = find_points(grid)
path = bfs_path(grid, start, end)
flag = decode_from_path(path)
print("[+] Path length:", len(path))
print("[+] Decoded:", flag)
if __name__ == "__main__":
main()题目文本保存成 maze.txt:
python solve.py maze.txt输出:
[+] Path length: 1089
[+] Decoded: VishwaCTF{p4th_1s_th3_m3ss4g3_00_57d006d5}The Curator
一开始看起来像 RSA 题,因为有 n / c1 / c2,还提到了:
p, q有隐藏关系seed藏在素数里c2 = pow(session_key ^ MAGIC, e, n)
但真正能直接利用的,其实是 LCG 前 8 个输出公开。
题目已经明说:
- 前 8 个 LCG 输出是公开的
- 后续输出拿去做 XOR 流加密
这意味着只要恢复 LCG 参数,就可以直接把 encrypted_flag 解出来,甚至不用先处理 RSA。
exp:
outs = [980887876, 699919547, 2058135724, 3888182547, 3474875028, 107192043, 215891708, 1328661059]
ct = bytes.fromhex("b2723f1b432adff7c2009fe0e7cf4f5c10a9bf6c1a38aa50b6645fa7725823f20ae8fd9787946c5135965f200b1fd2e7fb353c8287b821")
M = 2**32
x1, x2, x3 = outs[:3]
# recover A, C, seed
d1 = (x2 - x1) % M
d2 = (x3 - x2) % M
A = (d2 * pow(d1, -1, M)) % M
C = (x2 - A * x1) % M
seed = ((x1 - C) * pow(A, -1, M)) % M
print(f"A = {hex(A)}")
print(f"C = {hex(C)}")
print(f"seed = {hex(seed)}")
# verify first 8 outputs
x = seed
check = []
for _ in range(8):
x = (A * x + C) % M
check.append(x)
print("verify:", check == outs)
# generate stream, skip first 8 public outputs
x = seed
stream = []
for _ in range(8 + len(ct)):
x = (A * x + C) % M
stream.append(x)
keystream = bytes(v & 0xff for v in stream[8:8 + len(ct)])
pt = bytes(c ^ k for c, k in zip(ct, keystream))
print(pt.decode())VishwaCTF{s33ds_4r3_n3v3r_s4f3_1ns1d3_pr1m3s_4nd_n01s3}
MISC
Fragmented Evidence
这题给了一份日志文件 server.log,表面上看大部分都是正常系统日志,但其中夹杂了几条比较突兀的异常记录:多次出现 packet anomaly detected id=...,最后还有一条 backup failed code=...。这些字段明显不像普通错误码,更像是被拆碎后埋进日志里的数据。
- 观察异常字段
按时间顺序把所有异常值提取出来:
Zmxh
Z3tP
YmZ1
c2Nh
dGVk
VHJ1dGh9这些字符串只包含 Base64 常见字符,看起来就是被分段保存的 Base64 数据。相关片段都直接出现在日志里的 id= 和 code= 后面。
- 拼接并解码
把它们按出现顺序拼接:
ZmxhZ3tPYmZ1c2NhdGVkVHJ1dGh9对这串做 Base64 解码,得到:
flag{ObfuscatedTruth}exp:
import base64
import re
data = open("server.log", "r", encoding="utf-8").read()
parts = re.findall(r'id=([A-Za-z0-9+/=]+)', data)
parts += re.findall(r'code=([A-Za-z0-9+/=]+)', data)
b64 = ''.join(parts)
print("[+] joined:", b64)
decoded = base64.b64decode(b64).decode()
print("[+] decoded:", decoded)
inner = decoded.removeprefix("flag{").removesuffix("}")
print("[+] submit:", f"VishwaCTF{{{inner}}}")VishwaCTF{ObfuscatedTruth}
BOOT
这个 ISO 里真正的系统本体基本是官方 TinyCore 17.0。/boot/core.gz 和 /boot/vmlinuz 的 MD5 分别是 dab5a4578517269f1c5c39b0f4686af9、dbe0adc7f7bba17ef29cbb5280c8ded1,和官方 distribution_files 里的 core.gz、vmlinuz 完全一致;但官方 TinyCore-17.0.iso 的 MD5 是 6f6eec3518c70b394ef3c41711b1fe6d,说明题目作者改的不是系统本体,而是 ISO / boot 层。
继续看 /boot/isolinux/isolinux.bin,在偏移 0x6000 处能看到被塞进去的 3 行同样的字符串:
9d5zYNcj9f1S46vC74aruPgE9b6T3ceX4Qsa2VQAbVnDFfTr这串东西看起来像 Base64,但解出来是随机字节;改用 Base58 解码,就直接得到:
VishwaCTF{iM4G35_4Re_n0t_th4T_c00L}一行 Python 复现:
alphabet='123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
s='9d5zYNcj9f1S46vC74aruPgE9b6T3ceX4Qsa2VQAbVnDFfTr'
n=0
for ch in s:
n = n*58 + alphabet.index(ch)
print(n.to_bytes((n.bit_length()+7)//8, 'big').decode())UnderWorld - P1
P1 我没有找到第二个同样“完整拼出 VishwaCTF{...}”的容器,但在龙身上的一个桶里,钻石名字明确拼出的是:
No Emeralds here所以 P1 最可能 是:
VishwaCTF{No_Emeralds_here}
没有想到真是()这也太像fakeflag了
VishwaCTF{no_emeralds_here}
UnderWorld - P2
这是一个 Minecraft 世界存档,
已确认的:
VishwaCTF{m1n3cr4f7_15_fun}
这个是 P2,因为在龙头附近一个箱子里,27 个钻石的自定义名字按槽位正好拼出整串
The-Lost-Client
这张 PNG 本体是单色图,真正有用的是我从文件里直接抠出来的 XMP 元数据:creator = "Tata and.........",UserComment = "Its a generational business family",title = "V!"。这里后半段刚好是 9 个点,很像在遮一个 9 字母姓氏;结合“generational business family”和 V!,我现在认为它更像是在指 Vijaypat Singhania,而不是前面猜过的 Ajay / Venu。Times of India 也把 Vijaypat Singhania写成来自一个显赫商业家族的著名商界人物。
接着看“ex-chairman of a reputed institute in India”这部分,IIMA 官方档案明确写了两点:一是 “Dr. Vijaypat Singhania” 页面;二是 IIMA 的历任 Board of Governors 主席列表里,Dr. Vijaypat Singhania 的任期是 2007-03-29 到 2012-03-28。也就是说,他对应的机构就是 Indian Institute of Management Ahmedabad。
所以题目要的机构首字母缩写应当是:
IIMA
Jigsaw QR
二维码4*4被打乱,写个脚本拼接一下
4x4 拼法可以按当前图块编号这样排:
2 6 15 13
11 14 12 3
5 4 1 7
0 8 10 9按“当前图片从左到右、从上到下编号 0~15”来排。
exp:
# exp.py
from PIL import Image
from pyzbar.pyzbar import decode
IMG_PATH = "shuffled_flag1.png"
OUT_PATH = "recovered_qr.png"
# 按“原图从左到右、从上到下编号 0~15”
# 下面这个列表表示:拼好后的第 pos 个位置,应该放原图里的哪一块
ORDER = [
2, 6, 15, 13,
11, 14, 12, 3,
5, 4, 1, 7,
0, 8, 10, 9
]
def split_4x4(img):
w, h = img.size
xs = [round(i * w / 4) for i in range(5)]
ys = [round(i * h / 4) for i in range(5)]
tiles = []
for r in range(4):
for c in range(4):
tile = img.crop((xs[c], ys[r], xs[c + 1], ys[r + 1]))
tiles.append(tile)
return tiles
def rebuild(tiles, order):
max_w = max(t.size[0] for t in tiles)
max_h = max(t.size[1] for t in tiles)
canvas = Image.new("RGB", (max_w * 4, max_h * 4), "white")
for pos, src_idx in enumerate(order):
r, c = divmod(pos, 4)
tile = tiles[src_idx].resize((max_w, max_h), Image.NEAREST)
canvas.paste(tile, (c * max_w, r * max_h))
return canvas
def main():
img = Image.open(IMG_PATH).convert("RGB")
tiles = split_4x4(img)
qr = rebuild(tiles, ORDER)
qr.save(OUT_PATH)
print(f"[+] saved: {OUT_PATH}")
res = decode(qr)
if res:
print("[+] flag:", res[0].data.decode())
else:
print("[-] decode failed, scan recovered_qr.png manually")
if __name__ == "__main__":
main()VishwaCTF{t00_sm4rt_t0_us3_brut3_f0rc3}
Reverse
Messed Up
这题不是正常输入正确 secret 后给你 success 的那种程序。
程序运行后无论你输入什么,最后都会走到:
Your Secret "xxx" is invalid!
Byy!真正的 flag 被作者“藏”在程序初始化时压到栈上的一组 8 字节常量里,需要静态提取。
附件是一个 64 位 ELF,静态链接,未 strip。
直接运行可见它的行为大致是:
Enter Secret:
Your Secret "输入内容" is invalid!
Byy!程序会:
- 输出
Enter Secret: read(0, buf, 0x7f)读入输入- 去掉末尾换行
- 打印:
Your Secret "- 你的输入
" is invalid!\nByy!\n
也就是说,它表面上像是在校验输入,实际上主流程根本没有真正的 success 输出。
程序初始化阶段会往栈上放很多 8 字节常量,比如:
[rsp-0x48] = 0x954e20f865db128e[rsp-0x38] = 0x5b70de7570bc89c2[rsp-0x30] = 0x794b3d6bbf3f238f[rsp-0x28] = 0x212aa49b64d7e65d[rsp-0x20] = 0x90bafc29c34b62bd[rsp-0x18] = 0xa0564f32e8a3db99[rsp-0x10] = 0x0000000000b4c144
以及另一组:
[rsp-0x08] = 0xf01d008a00af7ccb[rsp+0x08] = 0x0f33bf0218cfe094[rsp+0x10] = 0x26324f198f0a58c9[rsp+0x18] = 0x5375d7af1388d16c[rsp+0x20] = 0xa3d7a350f27a568e[rsp+0x28] = 0x81061a6d8c90eeea[rsp+0x30] = 0x0000000000c9e065
把对应项异或后,可以直接还原出字符串。
- 先还原程序提示语
[rsp-0x48] ^ [rsp-0x08] = "Enter Se"
[rsp-0x40] ^ [rsp+0x00] = "cret: "这正好对应程序的提示:
Enter Secret:- 再还原隐藏 flag
[rsp-0x38] ^ [rsp+0x08] = "VishwaCT"
[rsp-0x30] ^ [rsp+0x10] = "F{50rry_"
[rsp-0x28] ^ [rsp+0x18] = "17_w4s_r"
[rsp-0x20] ^ [rsp+0x20] = "3411y_m3"
[rsp-0x18] ^ [rsp+0x28] = "s53d_UP!"
[rsp-0x10] ^ [rsp+0x30] = "!!}"拼起来就是:
VishwaCTF{50rry_17_w4s_r3411y_m3s53d_UP!!!}因为这个程序并不是“把 flag 当作 secret 校验”的逻辑。
它真正执行的主流程,读完输入后走的是:
- 长度处理
- 去掉换行
- 拼接输出
- 固定打印 invalid
也就是说:
- flag 是被藏在程序里的
- 不是拿来给程序验证的
所以你把 flag 输入进去,程序依旧会显示 invalid,这是正常现象。
exp
下面这个脚本可以直接把隐藏 flag 还原出来:
parts = [
0x5b70de7570bc89c2 ^ 0x0f33bf0218cfe094, # VishwaCT
0x794b3d6bbf3f238f ^ 0x26324f198f0a58c9, # F{50rry_
0x212aa49b64d7e65d ^ 0x5375d7af1388d16c, # 17_w4s_r
0x90bafc29c34b62bd ^ 0xa3d7a350f27a568e, # 3411y_m3
0xa0564f32e8a3db99 ^ 0x81061a6d8c90eeea, # s53d_UP!
0x0000000000b4c144 ^ 0x0000000000c9e065, # !!}
]
flag = b"".join(x.to_bytes(8, "little").rstrip(b"\x00") for x in parts)
print(flag.decode())VishwaCTF{50rry_17_w4s_r3411y_m3s53d_UP!!!}
ArtGallery
解包 APK 后,能看到包名是:
com.ctf.artgalleryActivity 主要有三个:
com.ctf.artgallery.MainActivity
com.ctf.artgallery.GalleryActivity
com.ctf.artgallery.CanvasActivity正常流程是:
MainActivity -> GalleryActivity但真正和 flag 相关的是 CanvasActivity。
在 GalleryActivity 里看事件绑定,可以看到有一个长按逻辑。
关键函数大意如下:
lambda$onCreate$3$com-ctf-artgallery-GalleryActivity(View v)它会先弹一个提示:
Scanning art for hidden data...然后延迟 800ms 执行一个 runnable。
继续跟这个 runnable:
lambda$onCreate$2$com-ctf-artgallery-GalleryActivity()核心逻辑就是:
Intent i = new Intent(this, CanvasActivity.class);
startActivity(i);也就是说:
在 GalleryActivity 里长按图片,就会进入真正的隐藏界面 CanvasActivity。
CanvasActivity 里最关键的是这个函数:
g()反汇编逻辑大致是:
if (!nativeLoaded) return "ACCESS_DENIED";
if (h()) return "ACCESS_DENIED";
int signal = computeRuntimeSignal();
if (!verifyGateNative(signal)) return "ACCESS_DENIED";
byte[] flag = decryptFlagNative(signal);
return new String(flag, UTF_8);也就是分 4 步:
- 检查 native 是否加载
- 反调试检查
h() - 计算
runtimeSignal - 交给 native:
verifyGateNative(signal)decryptFlagNative(signal)
h() 的逻辑不复杂:
Debug.isDebuggerConnected()
Debug.waitingForDebugger()然后再跑一个小循环计时:
- 如果执行时间过长,怀疑被调试
- 就直接拒绝
所以它本质就是个普通反调试门槛,不是重点。
computeRuntimeSignal() 会取 APK 的签名信息:
PackageManager.getPackageInfo(...)- 取
signingInfo - 对签名字节做
SHA-256 - 取前 4 个字节拼成一个 32-bit 值
- 再和包名 hash、几个常数做异或/rotate
最后得到一个 signal。
看起来很像“必须真机运行、必须原签名”的严密校验,但后面分析 native 会发现:
这个 signal 只用于过门,真正 flag 解密并不依赖它。
APK 里带了多个架构的 so:
lib/x86/libartvault.so
lib/x86_64/libartvault.so
lib/armeabi-v7a/libartvault.so
lib/arm64-v8a/libartvault.so直接分析 x86_64/libartvault.so 最方便。
导出符号可以看到两个 JNI 函数:
Java_com_ctf_artgallery_CanvasActivity_verifyGateNative
Java_com_ctf_artgallery_CanvasActivity_decryptFlagNative这个函数很短,逻辑如下:
bool verifyGateNative(int x) {
x ^= 0x6c8e9cf5;
x = mix32(x); // 一段类似 murmur/hash 的混合
return x == 0xd15ea5ed;
}其中 mix32 是:
x ^= x >> 16;
x *= 0x7feb352d;
x ^= x >> 15;
x *= 0x846ca68b;
x ^= x >> 16;所以它就是一个本地校验门。
但这还不是关键,因为真正的 flag 在另一个函数里。
分析 decryptFlagNative 会发现:
- 它接收参数
signal - 但函数主体里根本没有真正使用这个 signal 去参与解密
- 也就是说,只要静态逆出算法,就能直接拿到 flag
so 的 .rodata 里有三段数据,每段 11 字节:
a = bytes.fromhex("c1e81ff4ac02c6080f6135")
b = bytes.fromhex("999f79b553f3dedc237cf9")
c = bytes.fromhex("9a105eee235d979e4b1fb3")native 先按如下方式交错拼接:
tmp[0] = a[0]
tmp[1] = b[0]
tmp[2] = c[0]
tmp[3] = a[1]
tmp[4] = b[1]
tmp[5] = c[1]
...得到 33 字节中间数组。
.rodata 里还有一个 33 字节的置换表:
perm = bytes.fromhex(
"201c1110080713010500040f12150e1d02160d031e061b090b19140c1f1a180a17"
)含义是:
out[i] = tmp[perm[i]]初始种子:
state = 0x7f4a7c15每轮:
state = (state * 0x19660d + 0x3c6ef35f) & 0xffffffff
key = (state >> ((i & 3) * 8)) & 0xff
key ^= ((i * 31) + 0x11) & 0xff
out[i] ^= key还有一个 16 字节表:
sbox = bytes.fromhex("06040c050007020e010f030d080a090b")对每个字节高 4 位和低 4 位分别替换:
hi = sbox[(x >> 4) & 0xf]
lo = sbox[x & 0xf]
x = (hi << 4) | lo最后再按位置做循环右移:
r = (i % 5) + 1
x = ror8(x, r)做完就是明文。
exp
# solve_art_gallery.py
def ror8(x, r):
r &= 7
return ((x >> r) | ((x << (8 - r)) & 0xff)) & 0xff
perm = bytes.fromhex(
"201c1110080713010500040f12150e1d02160d031e061b090b19140c1f1a180a17"
)
a = bytes.fromhex("c1e81ff4ac02c6080f6135")
b = bytes.fromhex("999f79b553f3dedc237cf9")
c = bytes.fromhex("9a105eee235d979e4b1fb3")
sbox = bytes.fromhex("06040c050007020e010f030d080a090b")
# step1: interleave 3 chunks into 33 bytes
tmp = bytearray(33)
ia = ib = ic = 0
for i in range(33):
if i % 3 == 0:
tmp[i] = a[ia]
ia += 1
elif i % 3 == 1:
tmp[i] = b[ib]
ib += 1
else:
tmp[i] = c[ic]
ic += 1
# step2: permutation
buf = bytearray(33)
for i, p in enumerate(perm):
buf[i] = tmp[p]
# step3~5: PRNG xor -> nibble substitution -> rotate right
state = 0x7f4a7c15
res = bytearray(33)
for i in range(33):
state = (state * 0x19660d + 0x3c6ef35f) & 0xffffffff
key = (state >> ((i & 3) * 8)) & 0xff
key ^= ((i * 31) + 0x11) & 0xff
x = buf[i] ^ key
hi = sbox[(x >> 4) & 0xf]
lo = sbox[x & 0xf]
x = ((hi << 4) | lo) & 0xff
x = ror8(x, (i % 5) + 1)
res[i] = x
print(res.decode())VishwaCTF{secret_gallery_exposed}
Web
Heap of Secrets
用 Chrome 打开题目页。
按 F12 → Memory 面板。
选 Heap snapshot → 点 Take snapshot
然后保存下来搜索就行
VishwaCTF{h34p_5n4p5h0t_1s_D3ep_M3m0ry}
Keymaster Secrets
打开题目站点后,首页是一个伪装成 Apache Syncope Console 的登录页面,页面标题和底部都明确给出版本:
Apache Syncope v4.0.3题目描述也在不断强调:
- Apache Syncope
- XML 相关漏洞
- 外部实体被“修复”
- Keymaster Parameters
这几个关键词已经非常明显地把方向指向 Syncope 的 Keymaster 参数 XXE。
一开始如果直接打常规登录、默认口令、REST 路径,都会发现站点并不是完整暴露原版 Syncope,而是一个做过裁剪/伪装的题目环境,所以继续硬撞登录并不高效。
- 查看
robots.txt
访问:
/robots.txt得到:
User-agent: *
Disallow: /maintenance
Disallow: /api/docs
Disallow: /rest/这里的 robots.txt 其实就是明示,告诉我们有几个“平时不想被搜到”的路径值得看:
/maintenance/api/docs/rest/
- 访问
/maintenance
打开:
/maintenance会看到一个维护页面。
真正有价值的是查看页面源码,在 HTML 注释中发现了泄露信息:
<!--
TODO (ops-team): remove before go-live
Emergency console access for maintenance window:
Username : admin
Password : S3cur3Syncop3!@dm1n
Temp access expires: 2026-06-01
NOTE: BI reporting service coming soon on separate port — token in runtime dir
-->这说明开发/运维把敏感信息直接留在了源码注释里。
- 访问
/api/docs
打开:
/api/docs这个页面是伪造出来的 REST API 文档,里面列出了几个关键接口:
/rest/users/import
/rest/config/validate
/rest/keymaster/params
/rest/server/info其中最关键的是:
POST /rest/keymaster/params文档中明确写着它会:
- 服务端解析 XML
- 取出
<value> - 存储并返回
同时文档还专门写了一句类似“已阻止包含 SYSTEM entity 的 DOCTYPE”,这其实就是在强行把人往 XXE / CVE 上引。
登录进去继续查看这些页面源码后,可以直接拿到 flag:
VishwaCTF{XXE_1nj3ct10n_4p4ch3_sync0p3_CVE-2026-23795}
