377 lines
23 KiB
Python
377 lines
23 KiB
Python
"""Offline, synthetic-only AIR checks for SnapshotBridge; never starts the game.
|
|
|
|
Generated AS3, SWFs, requests and results stay in the ignored local runtime
|
|
directory. The harness only loads the already prepared library SWFs and tables.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import subprocess
|
|
import uuid
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
SOURCE = Path(__file__).resolve().parent
|
|
LOCAL = ROOT / "local_state/battle_runtime"
|
|
|
|
HARNESS = r'''
|
|
package {
|
|
import flash.desktop.NativeApplication;
|
|
import flash.display.Loader;
|
|
import flash.display.Sprite;
|
|
import flash.events.Event;
|
|
import flash.events.IOErrorEvent;
|
|
import flash.events.InvokeEvent;
|
|
import flash.events.UncaughtErrorEvent;
|
|
import flash.filesystem.File;
|
|
import flash.filesystem.FileMode;
|
|
import flash.filesystem.FileStream;
|
|
import flash.system.ApplicationDomain;
|
|
import flash.system.LoaderContext;
|
|
import flash.utils.ByteArray;
|
|
import flash.utils.describeType;
|
|
public class SnapshotBridgeCheck extends Sprite {
|
|
private var domain:ApplicationDomain = new ApplicationDomain(ApplicationDomain.currentDomain);
|
|
private var names:Array = ["framework", "main", "baseui", "mainui", "mainui2", "mainui3", "movieclip"];
|
|
private var loaders:Array = [];
|
|
private var index:int = 0;
|
|
private var root:File;
|
|
private var output:File;
|
|
private var request:Object;
|
|
private var finished:Boolean = false;
|
|
private var frameworkReady:Boolean = false;
|
|
public function SnapshotBridgeCheck() {
|
|
loaderInfo.uncaughtErrorEvents.addEventListener(UncaughtErrorEvent.UNCAUGHT_ERROR,
|
|
function(e:UncaughtErrorEvent):void {
|
|
e.preventDefault(); finish({ok:false, error:String(e.error)});
|
|
});
|
|
NativeApplication.nativeApplication.addEventListener(InvokeEvent.INVOKE, invoke);
|
|
}
|
|
private function invoke(e:InvokeEvent):void {
|
|
try {
|
|
root = new File(e.arguments[0]); output = new File(e.arguments[2]);
|
|
request = JSON.parse(readText(new File(e.arguments[1])));
|
|
loadNext();
|
|
} catch (error:Error) { finish({ok:false,error:error.getStackTrace() || error.toString()}); }
|
|
}
|
|
private function readText(file:File):String {
|
|
var s:FileStream = new FileStream(); s.open(file,FileMode.READ);
|
|
var text:String = s.readUTFBytes(s.bytesAvailable); s.close(); return text;
|
|
}
|
|
private function readBytes(file:File):ByteArray {
|
|
var s:FileStream = new FileStream(); s.open(file,FileMode.READ);
|
|
var bytes:ByteArray = new ByteArray(); s.readBytes(bytes); s.close(); return bytes;
|
|
}
|
|
private function cls(name:String):Class { return domain.getDefinition(name) as Class; }
|
|
private function loadNext():void {
|
|
if (index == names.length) { check(); return; }
|
|
var loader:Loader = new Loader(); loaders.push(loader);
|
|
loader.contentLoaderInfo.addEventListener(Event.COMPLETE,function(e:Event):void { loadNext(); });
|
|
loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,
|
|
function(e:IOErrorEvent):void { finish({ok:false,error:e.text}); });
|
|
var context:LoaderContext = new LoaderContext(false,domain); context.allowCodeImport = true;
|
|
loader.loadBytes(readBytes(root.resolvePath(names[index++] + ".library.swf")),context);
|
|
}
|
|
private function check():void {
|
|
try {
|
|
var table:Class = cls("net.pixvi.myr.center.Table");
|
|
var names:Array = JSON.parse(readText(root.resolvePath("table_index.json"))) as Array;
|
|
var rm:Class = cls("net.pixvi.common.manager.resource.RM"); rm["getInstance"]();
|
|
var stringLoader:Class = cls("net.pixvi.pfw.net.PiStringLoader");
|
|
stringLoader["globalCryptoMode"] = true;
|
|
stringLoader["globalJsonCryptoModeFunction"] = cls("net.pixvi.myrcryptor.MYRCryptor")["jsonDecodeHandler"];
|
|
var resourceClass:Class = cls("net.pixvi.common.net.resource.ResourceVo");
|
|
for each (var name:String in names) {
|
|
var packed:ByteArray = readBytes(root.resolvePath("tables/" + name + ".amf.zlib"));
|
|
var resource:Object = new resourceClass("data/table/" + name + ".json");
|
|
resource["crypto"] = true; resource["data"] = packed; rm["TXT"]["push"](resource);
|
|
var bytes:ByteArray = readBytes(root.resolvePath("tables/" + name + ".amf.zlib"));
|
|
bytes.uncompress(); bytes.objectEncoding = 3;
|
|
var value:Object = bytes.readObject();
|
|
table[name] = name != "team_info" && value.hasOwnProperty("datas") ? value.datas : value;
|
|
// ORIGINAL Table.startUp flattens the skin resource wrapper.
|
|
if (name == "skin_info") table[name] = value.skins;
|
|
}
|
|
table["monster_group"] = table["monster_setting"].group;
|
|
table["monster_element"] = table["monster_setting"].element;
|
|
__ACTION__
|
|
} catch (error:Error) { finish({ok:false,error:error.getStackTrace() || error.toString()}); }
|
|
}
|
|
private function initializeFramework():void {
|
|
if (!frameworkReady) {
|
|
addChild(cls("net.pixvi.common.center.StartUpCenter")["startUp"](stage,true,false,false,false));
|
|
var fixClass:Class = cls("net.pixvi.common.utils.PiFixVo");
|
|
var fs1:Object = new fixClass(); fs1.id = "fs1"; fs1.maxHWScale = 1.775;
|
|
var fs2:Object = new fixClass(); fs2.id = "fs2"; fs2.maxHWScale = 1.9125;
|
|
cls("net.pixvi.common.utils.StageLocator")["autoFull"](720,1136,[fs1,fs2]);
|
|
cls("net.pixvi.myr.battle.BattleGround")["firstStartUp"](); frameworkReady = true;
|
|
}
|
|
}
|
|
private function integrity(roster:Object):Object {
|
|
// Exercise BattlePanel's private cheatCheck through its ORIGINAL
|
|
// public completion handler. Native units come from TeamCenter;
|
|
// skip movie loading and install only local result callbacks.
|
|
initializeFramework();
|
|
var panelClass:Class = cls("net.pixvi.myr.panel.battle.BattlePanel");
|
|
var panel:Object = panelClass["getIns"]();
|
|
var groundClass:Class = cls("net.pixvi.myr.battle.BattleGround");
|
|
var ground:Object = new groundClass(); panel.ground = ground;
|
|
var battleClass:Class = cls("net.pixvi.myr.element.battle.BattleVo");
|
|
var battle:Object = new battleClass(); ground.vo = battle; panel.battle = battle;
|
|
var table:Class = cls("net.pixvi.myr.center.Table");
|
|
var authored:Object = table["stage_info"];
|
|
if (authored is Array) for each (var stageRow:Object in authored) {
|
|
if (stageRow.id == "0101") { authored = {"0101":stageRow}; break; }
|
|
}
|
|
battle["buildByObject"](authored["0101"].level["1"].battle);
|
|
var nativeTeam:Object = cls("net.pixvi.myr.center.TeamCenter")["getIns"]()["getBattleTeamVo"](roster.selectedTeam.teamName);
|
|
battle.teamDic[1] = nativeTeam; battle.teams = [nativeTeam];
|
|
var viewClass:Class = cls("net.pixvi.myr.battle.view.BattleMon");
|
|
var skillClass:Class = cls("net.pixvi.myr.view.skill.SkillType");
|
|
for (var i:int = 0; i < nativeTeam.mons.length; i++) {
|
|
var nativeVo:Object = nativeTeam.mons[i];
|
|
var view:Object = new viewClass();
|
|
view.vo = nativeVo.monsterVo; view.monVo = nativeVo; view.teamVo = nativeTeam;
|
|
// The pure skill portion of BattleMon.init, without buildView
|
|
// or image/movie loading. Skill parameters stay in original code.
|
|
view.skill_1 = skillClass["getSkill"](view.vo.skill_1,view.vo.skill_1_lv);
|
|
view.skill_2 = skillClass["getSkill"](view.vo.skill_2,view.vo.skill_2_lv);
|
|
if (view.skill_1 != null) view.skill_1["init"](view);
|
|
if (view.skill_2 != null) view.skill_2["init"](view);
|
|
nativeTeam.mons[i] = view;
|
|
}
|
|
var cooldownClass:Class = cls("net.pixvi.common.utils.Cooldowner");
|
|
ground.battleTime = new cooldownClass(1000); ground.winnerTeam = 1;
|
|
var dataClass:Class = cls("net.pixvi.myr.element.battle.BattleData");
|
|
panelClass["battleData"] = new dataClass();
|
|
panel.battlePosition = null;
|
|
var result:Object = null;
|
|
var completed:Function = function(data:Object):void {
|
|
result = {cheatNum:data.cheatNum, text:data.cheatRecords.text,
|
|
records:data.cheatRecords.mons, master:data.cheatRecords.master};
|
|
};
|
|
panel.onWinCallBack = completed; panel.onLoseCallBack = completed;
|
|
panel["battleCompleteHandler"]();
|
|
return result;
|
|
}
|
|
private function finish(result:Object):void {
|
|
if (finished) return; finished = true;
|
|
var s:FileStream = new FileStream(); s.open(output,FileMode.WRITE);
|
|
s.writeUTFBytes(JSON.stringify(result)); s.close();
|
|
NativeApplication.nativeApplication.exit(result.ok ? 0 : 1);
|
|
}
|
|
}
|
|
}
|
|
'''
|
|
|
|
REFLECT = r'''
|
|
var masterClass:Class = cls("net.pixvi.myr.element.master.MasterVo");
|
|
var master:Object = new masterClass();
|
|
cls("net.pixvi.myr.center.Game")["getIns"]()["master"] = master; master["init"]();
|
|
finish({ok:true, master:describeType(master).toXMLString(),
|
|
history:describeType(master.history).toXMLString(),
|
|
activity:describeType(master.activityHistory).toXMLString()});
|
|
'''
|
|
|
|
CHECK = r'''
|
|
var outcomes:Array = [];
|
|
var game:Object = cls("net.pixvi.myr.center.Game")["getIns"]();
|
|
initializeFramework();
|
|
var panel:Object = cls("net.pixvi.myr.panel.battle.BattlePanel")["getIns"]();
|
|
var positionClass:Class = cls("net.pixvi.myr.element.battle.BattlePosition");
|
|
for each (var test:Object in request.cases) {
|
|
var before:String = JSON.stringify(test.snapshot);
|
|
var previous:Object = game.master;
|
|
var position:Object = new positionClass(); panel.battlePosition = position;
|
|
var outcome:Object = {name:test.name};
|
|
try {
|
|
var roster:Object = SnapshotBridge.build(domain,test.snapshot,test.teamName);
|
|
var nativeTeam:Object = cls("net.pixvi.myr.center.TeamCenter")["getIns"]()["getBattleTeamVo"](test.teamName);
|
|
var units:Array = [];
|
|
var loadedIds:Array = [];
|
|
for each (var mon:Object in roster.master.monsters) {
|
|
loadedIds.push(mon.id);
|
|
if (roster.validation.selectedIds.indexOf(mon.id) < 0) continue;
|
|
var native:Object = cls("net.pixvi.myr.center.MonsterCenter")["getIns"]()["getBattleMonVoByMid"](mon.id);
|
|
units.push({id:mon.id,type:mon.type,level:mon.level,tplevel:mon.tplevel,
|
|
feel:mon.feel,skin:mon.skin,skinVo:mon.skinVo == null ? null : mon.skinVo.typeId,
|
|
skinEntry:mon.skinVo == null ? null : {monType:mon.skinVo.table().monType,
|
|
ability:mon.skinVo.ability,
|
|
sameOriginalEntry:mon.skinVo.table() === table["skin_info"][String(mon.skin)]},
|
|
entangle:mon.entangle,entangleLevel:mon.entangleLevel,entangleSkill:mon.entangleSkill,
|
|
potential:mon.potential_atk.val,skill_1:mon.skill_1,skill_2:mon.skill_2,
|
|
atk:mon.atk,def:mon.def,hp:mon.hp,dex:mon.dex,equip1:mon.equip1,equip2:mon.equip2,
|
|
additions:mon.abilityAdd.getRecord(),special:{atkPoi:native.atkPoi,
|
|
atkPoiType:native.atkPoiType,crit:native.crit,thorns:native.thorns},
|
|
battle:{atk:native.atk,def:native.def,hp:native.hpMax,dex:native.dex}});
|
|
}
|
|
var inventory:Array = [];
|
|
for each (var item:Object in roster.master.bag.items) {
|
|
var itemRecord:Object = {id:item.id,type:item.type,num:item.num};
|
|
if ("isUsed" in item) {
|
|
itemRecord.isUsed = item.isUsed; itemRecord.atk = item.atk.val;
|
|
itemRecord.hp = item.hp.val; itemRecord.atkPoiType = item.atkPoiType;
|
|
}
|
|
inventory.push(itemRecord);
|
|
}
|
|
var members:Array = [];
|
|
for each (native in nativeTeam.mons) members.push({mid:native.mid,teamPos:native.teamPos});
|
|
outcome.ok = true; outcome.validation = roster.validation;
|
|
outcome.contextUnchanged = panel.battlePosition === position;
|
|
outcome.installed = game.master === roster.master;
|
|
outcome.selectedSlots = roster.selectedTeam.monsters;
|
|
outcome.nativeAP = nativeTeam.ap; outcome.nativeMembers = members;
|
|
outcome.apFromRawLevel = cls("net.pixvi.myr.GameMath")["apByLevel"](test.snapshot.master.level);
|
|
outcome.units = units; outcome.inventory = inventory;
|
|
outcome.loadedMonsterIds = loadedIds;
|
|
outcome.history = {monLib:roster.master.history.monLib,
|
|
guide_record:roster.master.history.guide_record,unlockStage:roster.master.history.unlockStage,
|
|
passStage:roster.master.history.passStage,unlockCity:roster.master.history.unlockCity};
|
|
if (test.integrity === true) outcome.integrity = integrity(roster);
|
|
} catch (error:Error) {
|
|
outcome.ok = false; outcome.error = error.getStackTrace() || error.toString();
|
|
outcome.previousMasterRestored = game.master === previous;
|
|
}
|
|
outcome.inputUnchanged = before == JSON.stringify(test.snapshot);
|
|
outcomes.push(outcome);
|
|
}
|
|
finish({ok:true,cases:outcomes});
|
|
'''
|
|
|
|
|
|
def synthetic_snapshot(*, rich: bool = False) -> dict:
|
|
"""Explicit fake-account INPUTS; all derived stats remain in original AS3."""
|
|
tables = json.loads((LOCAL / "original/tables.json").read_text(encoding="utf-8"))
|
|
monster_table = tables["monster_info"].get("datas", tables["monster_info"])
|
|
fields = ("atk", "def", "hp", "dex", "crit", "atkSpd", "atkVim", "selfCure", "deadBoom",
|
|
"atkStun", "defStun", "atkPoi", "atkPoiDmg", "apCostSave", "skillCooldown",
|
|
"sunFire", "moonHeal", "thorns")
|
|
monsters, attributes = [], []
|
|
for i in range(3):
|
|
type_id = 1003010 if rich and i == 1 else 1001010
|
|
row = monster_table[str(type_id)]
|
|
monsters.append(dict(id=100000001 + i, typeId=type_id, level=1 + i, exp=0,
|
|
tpLevel=0, tpExp=0, feel=0, upStar=0, process=3, mode=2,
|
|
gAtk=row["atk_grow_min"], gDef=row["def_grow_min"],
|
|
gHp=row["hp_grow_min"], gDex=row["dex_grow_min"],
|
|
lock=0, sysLock=0, nicName="", timeGet=0, timeStart=0, roomId=0,
|
|
inExploreTeam=0, equip1=0, equip2=0, equip3=0, equip4=0, equip5=0,
|
|
pAtk=0, pDef=0, pHp=0, pDex=0, potentialLevel=1, giftTime=0,
|
|
skin=0, entangle=0, entangleLevel=0, entangleSkills=None))
|
|
attributes.append(dict(monsterId=100000001 + i, **dict.fromkeys(fields, 0)))
|
|
items = []
|
|
if rich:
|
|
monsters[0].update(equip2=100000101, pAtk=1, pDef=2, pHp=3, pDex=1)
|
|
monsters[1].update(skin=1003011, entangle=1, entangleLevel=1,
|
|
entangleSkills='{"1":1001}')
|
|
# Aggregate supplied attributes are authoritative, exactly as the server
|
|
# snapshot represents them. Do not recalculate equipment/skin bonuses.
|
|
attributes[0].update(hp=50, dex=3, atkPoi=2, atkPoiDmg=3)
|
|
attributes[1].update({"atk": 13, "def": 15, "atkVim": 2})
|
|
params = dict.fromkeys(fields, 0)
|
|
params.update(hp=50, dex=3, atkPoi=2, atkPoiDmg=3, atkPoiType=1)
|
|
items = [dict(id=100000101, typeId=50001, num=1, isUsed=1, itemClass=3,
|
|
equipParams=json.dumps(params))]
|
|
return dict(
|
|
master=dict(id=1, level=30, roleName="Offline fixture", farmName="", avatar=0,
|
|
createTime=0, exp=0, money=0, ti=0, ke=0, timeTi=0,
|
|
globalAtk=2 if rich else 0, globalDef=1 if rich else 0,
|
|
globalHp=5 if rich else 0, globalDex=1 if rich else 0),
|
|
monsters=monsters, monsterAttributes=attributes, items=items,
|
|
teams=[dict(teamName="teamA", teamType="battleTeam",
|
|
monsters=[100000003, 0, 100000001, 100000002, 0, 0, 0])],
|
|
history=dict(numAddMoney=0, numFeedMonsters={}, numKillMonsters={}, numChicken=0,
|
|
countBattle=0, historyGacha={}, passAchi=[], passTask={}, unlockTask={},
|
|
loopTask={}, guide_main="", guide_record=["firstOut"], unlockCity=[1],
|
|
unlockStage={"0101": [1]}, passStage={"0101": [1]},
|
|
monLib=[1001010, 1003010], equipLib=["50001"], payTypeCount={},
|
|
everyDayBuyProductNum={}),
|
|
data2=dict(unlockSkins=[1003011], timeEggItems=[]),
|
|
activityHistory=dict(dailyGift=dict(dailyGiftCheckTime=0, dailyGiftLevel=1,
|
|
dailyGiftCount=0, signCount=0),
|
|
vipInfo=dict(vipTime=0, getTime=0)))
|
|
|
|
|
|
def dependencies_available() -> bool:
|
|
return (os.name == "nt" and shutil.which("java") is not None
|
|
and (LOCAL / "air_sdk/lib/mxmlc-cli.jar").is_file()
|
|
and (LOCAL / "original/main.library.swf").is_file())
|
|
|
|
|
|
def run_harness(request: dict, *, action: str = REFLECT) -> dict:
|
|
# Match the existing probe's reviewed, pinned dependencies, without prepare(),
|
|
# network acquisition, account caches, or writes into another owner's build.
|
|
from tools.battle_runtime.trusted import LIBRARY_FILES, SDK_FILES, verify_files
|
|
|
|
for root, pins in ((LOCAL / "air_sdk", SDK_FILES), (LOCAL / "original", LIBRARY_FILES)):
|
|
errors = verify_files(root, pins)
|
|
if errors:
|
|
raise RuntimeError(f"Untrusted local snapshot-check dependencies: {errors}")
|
|
build = LOCAL / "snapshot_bridge_checks" / uuid.uuid4().hex
|
|
build.mkdir(parents=True)
|
|
(build / "SnapshotBridgeCheck.as").write_text(HARNESS.replace("__ACTION__", action), encoding="utf-8")
|
|
(build / "compiler-config.xml").write_text("<flex-config/>", encoding="utf-8")
|
|
sdk = LOCAL / "air_sdk"
|
|
command = [shutil.which("java") or "java", "-Duser.language=en", "-Duser.country=US", "-jar",
|
|
str(sdk / "lib/mxmlc-cli.jar"), "-load-config=" + str(build / "compiler-config.xml"),
|
|
"-compiler.external-library-path=" + str(sdk / "frameworks/libs/air/airglobal.swc"),
|
|
"-compiler.library-path=" + str(sdk / "frameworks/libs/core.swc"),
|
|
"-compiler.source-path=" + str(SOURCE), "-swf-version=50", "-debug=true",
|
|
"-default-frame-rate=50", "-output=" + str(build / "SnapshotBridgeCheck.swf"),
|
|
str(build / "SnapshotBridgeCheck.as")]
|
|
compiler = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, encoding="utf-8",
|
|
errors="replace", timeout=60, creationflags=subprocess.CREATE_NO_WINDOW)
|
|
evidence = {"compiler_exit_code": compiler.returncode, "compiler_stdout": compiler.stdout,
|
|
"compiler_stderr": compiler.stderr,
|
|
"source_sha256": hashlib.sha256((SOURCE / "SnapshotBridge.as").read_bytes()).hexdigest()
|
|
if (SOURCE / "SnapshotBridge.as").is_file() else None}
|
|
if compiler.returncode:
|
|
raise RuntimeError("Snapshot bridge compilation failed: " + compiler.stdout + compiler.stderr)
|
|
(build / "check-app.xml").write_text('''<?xml version="1.0" encoding="UTF-8"?>
|
|
<application xmlns="http://ns.adobe.com/air/application/51.1">
|
|
<id>local.snapshotbridge.c''' + uuid.uuid4().hex + '''</id><versionNumber>0.0.1</versionNumber>
|
|
<filename>SnapshotBridgeCheck</filename><initialWindow><content>SnapshotBridgeCheck.swf</content>
|
|
<visible>false</visible><systemChrome>none</systemChrome><renderMode>cpu</renderMode>
|
|
</initialWindow><supportedProfiles>extendedDesktop</supportedProfiles></application>''', encoding="utf-8")
|
|
(build / "request.json").write_text(json.dumps(request), encoding="utf-8")
|
|
command = [str(sdk / "bin/adl64.exe"), "-runtime", str(sdk / "runtimes/air/win64"), "-nodebug",
|
|
"-profile", "extendedDesktop", str(build / "check-app.xml"), "--", str(LOCAL / "original"),
|
|
str(build / "request.json"), str(build / "result.json")]
|
|
runtime = subprocess.run(command, cwd=build, capture_output=True, timeout=45,
|
|
creationflags=subprocess.CREATE_NO_WINDOW)
|
|
result_path = build / "result.json"
|
|
evidence.update(process_exit_code=runtime.returncode,
|
|
result=json.loads(result_path.read_text(encoding="utf-8")) if result_path.exists() else None,
|
|
directory=str(build))
|
|
(build / "evidence.json").write_text(json.dumps(evidence, indent=2), encoding="utf-8")
|
|
if evidence["result"] is None:
|
|
raise RuntimeError(f"AIR snapshot check produced no result (exit {runtime.returncode})")
|
|
return evidence
|
|
|
|
|
|
def run_checks(cases: list[dict] | None = None) -> dict:
|
|
if cases is None:
|
|
cases = [dict(name=name, snapshot=synthetic_snapshot(rich=rich),
|
|
teamName="teamA", integrity=True)
|
|
for name, rich in (("plain", False), ("equipment_skin_entangle", True))]
|
|
empty = synthetic_snapshot()
|
|
empty["monsterAttributes"] = []
|
|
cases.append(dict(name="empty_attributes", snapshot=empty, teamName="teamA", integrity=True))
|
|
return run_harness({"cases": cases}, action=CHECK)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import sys
|
|
sys.path.insert(0, str(ROOT))
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--reflect", action="store_true")
|
|
args = parser.parse_args()
|
|
evidence = run_harness({}) if args.reflect else run_checks()
|
|
print(json.dumps(evidence, indent=2))
|
|
sys.exit(0 if evidence["result"].get("ok") and
|
|
all(c["ok"] for c in evidence["result"].get("cases", [])) else 1)
|