diff --git a/bst@asphyxia/README.md b/bst@asphyxia/README.md new file mode 100644 index 0000000..e1e4ebc --- /dev/null +++ b/bst@asphyxia/README.md @@ -0,0 +1,9 @@ +# BeatStream + +Plugin Version: **v1.0.1** + +Supported Versions: + +- BeatStream アニムトライヴ + - Back end ✔ + - Web UI ✔ \ No newline at end of file diff --git a/bst@asphyxia/handlers/bst2/common.ts b/bst@asphyxia/handlers/bst2/common.ts new file mode 100644 index 0000000..89d0206 --- /dev/null +++ b/bst@asphyxia/handlers/bst2/common.ts @@ -0,0 +1,247 @@ +import { Bst2EventParamsMap, getKEventControl } from "../../models/bst2/event_params" +import { Bst2AccountMap, Bst2BiscoMap, Bst2CourseMap, Bst2MusicRecordMap, Bst2PlayerMap, Bst2SurveyMap, Bst2TipsMap, Bst2UnlockingInfoMap, IBst2Account, IBst2Base, IBst2Bisco, IBst2Course, IBst2CrysisLog, IBst2Customization, IBst2Hacker, IBst2MusicRecord, IBst2Player, IBst2Survey, IBst2Tips, IBst2UnlockingInfo } from "../../models/bst2/profile" +import { Bst2CourseLogMap, Bst2StageLogMap, IBst2StageLog } from "../../models/bst2/stagelog" +import { bacK, BigIntProxy, boolme, fromMap, mapK, s16me, s32me, s8me, strme, toBigInt } from "../../utility/mapping" +import { isToday } from "../../utility/utility_functions" +import { DBM } from "../utility/db_manager" +import { readPlayerPostProcess, writePlayerPreProcess } from "./processing" + +export namespace Bst2HandlersCommon { + export const Common: EPR = async (_0, _1, send) => await send.object({ event_ctrl: { data: getKEventControl() } }) + + export const BootPcb: EPR = async (_0, _1, send) => await send.object({ sinfo: { nm: K.ITEM("str", "Asphyxia"), cl_enbl: K.ITEM("bool", 1), cl_h: K.ITEM("u8", 0), cl_m: K.ITEM("u8", 0) } }) + + export const StartPlayer: EPR = async (_, data, send) => { + let params = fromMap(Bst2EventParamsMap) + let rid = $(data).str("rid") + let account = DB.FindOne(rid, { collection: "bst.bst2.player.account" }) + if (account == null) params.playerId = -1 + params.startTime = BigInt(Date.now()) + send.object(mapK(params, Bst2EventParamsMap)) + } + + export const PlayerSucceeded: EPR = async (_, data, send) => { + let rid = $(data).str("rid") + let account: IBst2Account = await DB.FindOne(rid, { collection: "bst.bst2.player.account" }) + let result + if (account == null) { + result = { + play: false, + data: { name: "" }, + record: {}, + hacker: {}, + phantom: {} + } + } else { + let base: IBst2Base = await DB.FindOne(rid, { collection: "bst.bst2.player.base" }) + let records: IBst2MusicRecord[] = await DB.Find({ collection: "bst.bst2.playData.musicRecord#userId", userId: account.userId }) + result = { + play: true, + data: { name: base.name }, + record: {}, + hacker: {}, + phantom: {} + } + } + send.object(mapK(result, { + play: boolme(), + data: { name: strme() }, + record: {}, + hacker: {}, + phantom: {} + })) + } + + export const ReadPlayer: EPR = async (_, data, send) => { + let refid = $(data).str("rid") + let account = await DB.FindOne(refid, { collection: "bst.bst2.player.account" }) + if (account == null) return await send.deny() + + let base = await DB.FindOne(refid, { collection: "bst.bst2.player.base" }) + let survey = await DB.FindOne(refid, { collection: "bst.bst2.player.survey" }) || fromMap(Bst2SurveyMap) + let unlocking = await DB.Find(refid, { collection: "bst.bst2.player.unlockingInfo" }) + let customize = await DB.FindOne(refid, { collection: "bst.bst2.player.customization" }) + let tips = await DB.FindOne(refid, { collection: "bst.bst2.player.tips" }) || fromMap(Bst2TipsMap) + let hacker = await DB.Find(refid, { collection: "bst.bst2.player.hacker" }) + let crysis = await DB.Find(refid, { collection: "bst.bst2.player.event.crysis" }) + let bisco = await DB.FindOne(refid, { collection: "bst.bst2.player.bisco" }) || fromMap(Bst2BiscoMap) + let records = await DB.Find({ collection: "bst.bst2.playData.musicRecord#userId", userId: account.userId }) + let courses = await DB.Find({ collection: "bst.bst2.playData.course#userId", userId: account.userId }) + + account.previousStartTime = account.standardTime + account.standardTime = BigInt(Date.now()) + account.ea = true + account.intrvld = 0 + account.playCount++ + account.playCountToday++ + let eventPlayLog: { crysis?: IBst2CrysisLog[] } = {} + if (crysis.length != 0) eventPlayLog.crysis = crysis + + let player: IBst2Player = { + pdata: { + account: account, + base: base, + survey: survey, + opened: {}, + item: (unlocking.length == 0) ? {} : { info: unlocking }, + customize: customize, + tips: tips, + hacker: (hacker.length == 0) ? {} : { info: hacker }, + playLog: eventPlayLog, + bisco: { pinfo: bisco }, + record: (records.length == 0) ? {} : { rec: records }, + course: (courses.length == 0) ? {} : { record: courses } + } + } + send.object(readPlayerPostProcess(mapK(player, Bst2PlayerMap))) + } + + export const WritePlayer: EPR = async (_, data, send) => { + let player = bacK(writePlayerPreProcess(data), Bst2PlayerMap).data + let refid = player.pdata.account.refid + let userId = player.pdata.account.userId + let now = BigIntProxy(BigInt(Date.now())) + + let opm = new DBM.DBOperationManager() + + let oldAccount = await DB.FindOne(refid, { collection: "bst.bst2.player.account" }) + if (!oldAccount) { + do { + userId = Math.round(Math.random() * 99999999) + } while ((await DB.Find(null, { collection: "bst.bst2.player.account", userId: userId })).length > 0) + oldAccount = fromMap(Bst2AccountMap) + oldAccount.userId = userId + } else { + oldAccount.playCount++ + if (!isToday(toBigInt(oldAccount.standardTime))) { + oldAccount.dayCount++ + oldAccount.playCountToday = 1 + } else oldAccount.playCountToday++ + } + oldAccount.standardTime = BigIntProxy(BigInt(Date.now())) + opm.upsert(refid, { collection: "bst.bst2.player.account" }, oldAccount) + if (player.pdata.base) opm.upsert(refid, { collection: "bst.bst2.player.base" }, player.pdata.base) + if (player.pdata.item?.info?.length > 0) for (let u of player.pdata.item.info) opm.upsert(refid, { collection: "bst.bst2.player.unlockingInfo", type: u.type, id: u.id }, u) + if (player.pdata.customize) opm.upsert(refid, { collection: "bst.bst2.player.customization" }, player.pdata.customize) + if (player.pdata.tips) opm.upsert(refid, { collection: "bst.bst2.player.base" }, player.pdata.base) + if (player.pdata.hacker?.info?.length > 0) for (let h of player.pdata.hacker.info) { + h.updateTime = now + opm.upsert(refid, { collection: "bst.bst2.player.hacker", id: h.id }, h) + } + if (player.pdata.playLog?.crysis?.length > 0) for (let c of player.pdata.playLog.crysis) opm.upsert(refid, { collection: "bst.bst2.player.event.crysis", id: c.id, stageId: c.stageId }, c) + + await DBM.operate(opm) + send.object({ uid: K.ITEM("s32", oldAccount.userId) }) + } + + export const WriteStageLog: EPR = async (_, data, send) => { + await updateRecordFromStageLog(bacK(data, Bst2StageLogMap).data, false) + send.success() + } + + export const WriteCourseStageLog: EPR = async (_, data, send) => { + await updateRecordFromStageLog(bacK(data, Bst2StageLogMap).data, true) + send.success() + } + + async function updateRecordFromStageLog(stageLog: IBst2StageLog, isCourseStage: boolean) { + let query: Query = { collection: "bst.bst2.playData.musicRecord#userId", userId: stageLog.userId, musicId: stageLog.musicId, chart: stageLog.chart } + let oldRecord = await DB.FindOne(query) + + let time = Date.now() + stageLog.time = time + stageLog.isCourseStage = isCourseStage + + if (oldRecord == null) { + oldRecord = fromMap(Bst2MusicRecordMap) + oldRecord.musicId = stageLog.musicId + oldRecord.chart = stageLog.chart + oldRecord.clearCount = (stageLog.medal >= 3) ? 1 : 0 + oldRecord.score = stageLog.score + oldRecord.grade = stageLog.grade + oldRecord.gaugeTimes10 = stageLog.gaugeTimes10 + oldRecord.playCount = 1 + oldRecord.medal = stageLog.medal + oldRecord.combo = stageLog.combo + oldRecord.lastPlayTime = time + oldRecord.updateTime = time + oldRecord.userId = stageLog.userId + } else { + if (stageLog.medal >= 3) oldRecord.clearCount++ + if (oldRecord.score < stageLog.score) { + oldRecord.updateTime = time + oldRecord.score = stageLog.score + } + if (oldRecord.grade < stageLog.grade) { + oldRecord.updateTime = time + oldRecord.grade = stageLog.grade + } + if (oldRecord.gaugeTimes10 < stageLog.gaugeTimes10) { + oldRecord.updateTime = time + oldRecord.gaugeTimes10 = stageLog.gaugeTimes10 + } + if (oldRecord.medal < stageLog.medal) { + oldRecord.updateTime = time + oldRecord.medal = stageLog.medal + } + if (oldRecord.combo < stageLog.combo) { + oldRecord.updateTime = time + oldRecord.combo = stageLog.combo + } + oldRecord.lastPlayTime = time + oldRecord.playCount++ + } + DBM.upsert(null, query, oldRecord) + DBM.insert(null, stageLog) + } + + export const WriteCourseLog: EPR = async (_, data, send) => { + let courseLog = bacK(data, Bst2CourseLogMap).data + let query: Query = { collection: "bst.bst2.playData.course#userId", userId: courseLog.userId, courseId: courseLog.courseId } + let oldRecord = await DB.FindOne(query) + + let time = Date.now() + courseLog.time = time + + if (oldRecord == null) { + oldRecord = fromMap(Bst2CourseMap) + oldRecord.courseId = courseLog.courseId + oldRecord.score = courseLog.score + oldRecord.grade = courseLog.grade + oldRecord.gauge = courseLog.gauge + oldRecord.playCount = 1 + oldRecord.medal = courseLog.medal + oldRecord.combo = courseLog.combo + oldRecord.lastPlayTime = time + oldRecord.updateTime = time + oldRecord.userId = courseLog.userId + } else { + if (oldRecord.score < courseLog.score) { + oldRecord.updateTime = time + oldRecord.score = courseLog.score + } + if (oldRecord.grade < courseLog.grade) { + oldRecord.updateTime = time + oldRecord.grade = courseLog.grade + } + if (oldRecord.gauge < courseLog.gauge) { + oldRecord.updateTime = time + oldRecord.gauge = courseLog.gauge + } + if (oldRecord.medal < courseLog.medal) { + oldRecord.updateTime = time + oldRecord.medal = courseLog.medal + } + if (oldRecord.combo < courseLog.combo) { + oldRecord.updateTime = time + oldRecord.combo = courseLog.combo + } + oldRecord.lastPlayTime = time + oldRecord.playCount++ + } + DBM.upsert(null, query, oldRecord) + DBM.insert(null, courseLog) + + send.success() + } +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/bst2/processing.ts b/bst@asphyxia/handlers/bst2/processing.ts new file mode 100644 index 0000000..3e08cb0 --- /dev/null +++ b/bst@asphyxia/handlers/bst2/processing.ts @@ -0,0 +1,12 @@ +import { IBst2Player } from "../../models/bst2/profile" +import { KITEM2 } from "../../utility/mapping" +import { toFullWidth, toHalfWidth } from "../../utility/utility_functions" + +export function readPlayerPostProcess(player: KITEM2): KITEM2 { + if (player.pdata.base?.name != null) player.pdata.base.name["@content"] = toFullWidth(player.pdata.base.name["@content"]) + return player +} +export function writePlayerPreProcess(player: KITEM2): KITEM2 { + if (player.pdata.base?.name != null) player.pdata.base.name["@content"] = toHalfWidth(player.pdata.base.name["@content"]) + return player +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/bst2/webui.ts b/bst@asphyxia/handlers/bst2/webui.ts new file mode 100644 index 0000000..85e6ffd --- /dev/null +++ b/bst@asphyxia/handlers/bst2/webui.ts @@ -0,0 +1,39 @@ +import { IBst2Base, IBst2Customization } from "../../models/bst2/profile" +import { WebUIMessageType } from "../../models/utility/webui_message" +import { DBM } from "../utility/db_manager" +import { UtilityHandlersWebUI } from "../utility/webui" + +export namespace Bst2HandlersWebUI { + export const UpdateSettings = async (data: { + refid: string + name: string + rippleNote: number + sfxNormalNote: number + sfxRippleNote: number + sfxSlashNote: number + sfxStreamNote: number + backgroundBrightness: number + judgeText: number + rippleNoteGuide: number + streamNoteGuide: number + sfxFine: number + sfxStreamNoteTail: number + }) => { + try { + let customization = await DB.FindOne(data.refid, { collection: "bst.bst2.player.customization" }) + if (customization == null) throw new Error("No profile for refid=" + data.refid) + customization.custom[0] = data.rippleNote + customization.custom[2] = data.sfxNormalNote + customization.custom[3] = data.sfxRippleNote + customization.custom[4] = data.sfxSlashNote + customization.custom[5] = data.sfxStreamNote + customization.custom[6] = data.backgroundBrightness + customization.custom[7] = (data.judgeText << 0) | (data.rippleNoteGuide << 1) | (data.streamNoteGuide << 2) | (data.sfxStreamNoteTail << 3) | (data.sfxFine << 4) + customization.custom[9] = data.judgeText + DBM.update(data.refid, { collection: "bst.bst2.player.customization" }, customization) + UtilityHandlersWebUI.pushMessage("Save BeatStream Animtribe settings succeeded!", 2, WebUIMessageType.success, data.refid) + } catch (e) { + UtilityHandlersWebUI.pushMessage("Error while save BeatStream Animtribe settings: " + e.message, 2, WebUIMessageType.error, data.refid) + } + } +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/utility/batch.ts b/bst@asphyxia/handlers/utility/batch.ts new file mode 100644 index 0000000..87596d9 --- /dev/null +++ b/bst@asphyxia/handlers/utility/batch.ts @@ -0,0 +1,21 @@ +import { IBatchResult } from "../../models/utility/batch" +import { IPluginVersion } from "../../models/utility/plugin_version" +import { isHigherVersion } from "../../utility/utility_functions" +import { DBM } from "./db_manager" + +export namespace Batch { + let registeredBatch = <{ id: string, version: string, batch: () => Promise }[]>[] + + export async function execute(version: string): Promise { + for (let b of registeredBatch) { + if ((await DB.Find({ collection: "bst.batchResult", batchId: b.id })).length == 0) if (!isHigherVersion(version, b.version)) { + await b.batch() + await DBM.insert(null, { collection: "bst.batchResult", batchId: b.id }) + } + } + } + export function register(id: string, version: string, batch: () => Promise) { + registeredBatch.push({ id: id, version: version, batch: batch }) + } + +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/utility/batch_initialize.ts b/bst@asphyxia/handlers/utility/batch_initialize.ts new file mode 100644 index 0000000..fd9c86e --- /dev/null +++ b/bst@asphyxia/handlers/utility/batch_initialize.ts @@ -0,0 +1,7 @@ +import { Batch } from "./batch" +import { DBM } from "./db_manager" +import { bufferToBase64, log } from "../../utility/utility_functions" + +export function initializeBatch() { + /* Register batch here **/ +} diff --git a/bst@asphyxia/handlers/utility/common.ts b/bst@asphyxia/handlers/utility/common.ts new file mode 100644 index 0000000..4d819b1 --- /dev/null +++ b/bst@asphyxia/handlers/utility/common.ts @@ -0,0 +1,17 @@ +export namespace UtilityHandlersCommon { + export const WriteShopInfo: EPR = async (__, ___, send) => { + let result = { + sinfo: { + lid: K.ITEM("str", "ea"), + nm: K.ITEM("str", "Asphyxia shop"), + cntry: K.ITEM("str", "Japan"), + rgn: K.ITEM("str", "1"), + prf: K.ITEM("s16", 13), + cl_enbl: K.ITEM("bool", 0), + cl_h: K.ITEM("u8", 8), + cl_m: K.ITEM("u8", 0) + } + } + send.object(result) + } +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/utility/db_manager.ts b/bst@asphyxia/handlers/utility/db_manager.ts new file mode 100644 index 0000000..b4e5a1b --- /dev/null +++ b/bst@asphyxia/handlers/utility/db_manager.ts @@ -0,0 +1,212 @@ +import { ICollection } from "../../models/utility/definitions" +import { log } from "../../utility/utility_functions" + +export namespace DBM { + export interface IDBCollectionName extends ICollection<"dbManager.collectionName"> { + name: string + } + export interface IDBOperation { + refid?: string + query: TOperation extends "insert" ? null : Query + operation: TOperation + doc: TOperation extends "remove" ? null : T | Doc + isPublicDoc?: boolean + } + export class DBOperationManager { + public operations: IDBOperation[] = [] + + public push(...op: IDBOperation[]): void { + this.operations.push(...op) + } + public update>(refid: string | null, query: Query, data: Doc, isPublicDoc: boolean = true): void { + for (let o of this.operations) if (o.doc && DBOperationManager.isMatch(o.doc, query)) o.operation = "skip" + this.operations.push({ refid: refid, query: query, operation: "update", doc: data, isPublicDoc: isPublicDoc }) + } + public upsert>(refid: string | null, query: Query, data: Doc, isPublicDoc: boolean = true): void { + for (let o of this.operations) if (o.doc && DBOperationManager.isMatch(o.doc, query)) o.operation = "skip" + this.operations.push({ refid: refid, query: query, operation: "upsert", doc: data, isPublicDoc: isPublicDoc }) + } + public insert>(refid: string | null, data: Doc, isPublicDoc: boolean = true): void { + this.operations.push({ refid: refid, operation: "insert", query: null, doc: data, isPublicDoc: isPublicDoc }) + } + public remove>(refid: string | null, query: Query, isPublicDoc: boolean = true): void { + for (let o of this.operations) if (o.doc && DBOperationManager.isMatch(o.doc, query)) o.operation = "skip" + this.operations.push({ refid: refid, query: query, operation: "remove", doc: null, isPublicDoc: isPublicDoc }) + } + public async findOne>(refid: string | null, query: Query, isPublicDoc: boolean = true): Promise> { + for (let i = this.operations.length - 1; i >= 0; i--) { + let o = this.operations[i] + if (o.doc == null) continue + if (DBOperationManager.isMatch(o.doc, query) && ((o.refid && refid) ? (o.refid == refid) : true)) return o.doc + } + return ((refid == null) && isPublicDoc) ? await DB.FindOne(query) : await DB.FindOne(refid, query) + } + public async find>(refid: string | null, query: Query, isPublicDoc: boolean = true): Promise<(T | Doc)[]> { + let result: (T | Doc)[] = [] + for (let o of this.operations) { + if (o.doc == null) continue + if (DBOperationManager.isMatch(o.doc, query) && ((o.refid && refid) ? (o.refid == refid) : true)) result.push(o.doc) + } + return result.concat(await (((refid == null) && isPublicDoc) ? DB.Find(query) : DB.Find(refid, query))) + } + private static isMatch(entry: T | Doc, query: Query): boolean { + if (entry == null) return query == null + if (query.$where && !query.$where.apply(entry)) return false + let $orResult = null + let skipKeys = ["$where", "_id"] + for (let qk in query) { + if (skipKeys.includes(qk)) continue + switch (qk) { + case "$or": { + if ($orResult == null) $orResult = false + for (let or of query.$or) if (this.isMatch(entry, or)) $orResult = true + break + } + case "$and": { + for (let and of query.$and) if (!this.isMatch(entry, and)) return false + break + } + case "$not": { + if (this.isMatch(entry, query.$not)) return false + break + } + default: { + let value = entry[qk] + let q = query[qk] + if (value == q) continue + if ((typeof q != "object") && (typeof q != "function")) return false + if ((q.$exists != null)) if ((q.$exists && (value == null)) || (!q.$exists && (value != null))) return false + if (Array.isArray(value)) { + if (q.$elemMatch && !this.isMatch(value, q.$elemMatch)) return false + if (q.$size && (value.length != q.$size)) return false + continue + } else if ((typeof value == "number") || (typeof value == "string")) { + if (q.$lt) if (value >= q.$lt) return false + if (q.$lte) if (value > q.$lte) return false + if (q.$gt) if (value <= q.$gt) return false + if (q.$gte) if (value < q.$gte) return false + if (q.$in) if (!value.toString().includes(q.$in)) return false + if (q.$nin) if (value.toString().includes(q.$nin)) return false + if (q.$ne) if (value == q.$ne) return false + if (q.$regex) if (value.toString().match(q.$regex).length == 0) return false + continue + } else if (typeof value == "object") { + if (!this.isMatch(value, q)) return false + continue + } else if (q != null) return false + } + } + } + return ($orResult == null) || $orResult + } + } + export async function getCollectionNames(filter?: string): Promise { + let result = await DB.Find({ collection: "dbManager.collectionName" }) + if (filter != null) { + let filters = filter.split(",") + for (let i = 0; i < filter.length; i++) filters[i] = filters[i].trim() + let i = 0 + while (i < result.length) { + let removeFlag = false + for (let f of filters) if (f.startsWith("!") ? !result[i].name.includes(f) : result[i].name.includes(f)) { + result.splice(i, 1) + removeFlag = true + break + } + if (!removeFlag) i++ + } + } + + return result + } + + async function checkData>(data: T): Promise { + for (let k in data) if (k.startsWith("__")) delete data[k] + if (await DB.FindOne({ collection: "dbManager.collectionName", name: data.collection }) == null) { + await DB.Insert({ collection: "dbManager.collectionName", name: data.collection }) + } + } + export async function update>(refid: string | null, query: Query, data: Doc, isPublicDoc: boolean = true) { + checkData(data) + if (refid == null) return isPublicDoc ? await DB.Update(query, data) : await DB.Update(null, query, data) + else return await DB.Update(refid, query, data) + } + export async function upsert>(refid: string | null, query: Query, data: Doc, isPublicDoc: boolean = true) { + checkData(data) + if (refid == null) return isPublicDoc ? await DB.Upsert(query, data) : await DB.Upsert(null, query, data) + else return await DB.Upsert(refid, query, data) + } + export async function insert>(refid: string | null, data: Doc, isPublicDoc: boolean = true) { + checkData(data) + if (refid == null) return isPublicDoc ? await DB.Insert(data) : await DB.Insert(null, data) + else return await DB.Insert(refid, data) + } + export async function remove>(refid: string | null, query: Query, isPublicDoc: boolean = true) { + if (refid == null) return isPublicDoc ? await DB.Remove(query) : await DB.Remove(null, query) + else return await DB.Remove(refid, query) + } + + export async function operate(operations: DBOperationManager) { + let result = [] + for (let o of operations.operations) { + if (o.operation == "skip") continue + if (o.doc) delete o.doc._id + try { + switch (o.operation) { + case "insert": + result.push(await insert(o.refid, o.doc, o.isPublicDoc)) + break + case "update": + result.push(await update(o.refid, o.query, o.doc, o.isPublicDoc)) + break + case "upsert": + result.push(await upsert(o.refid, o.query, o.doc, o.isPublicDoc)) + break + case "remove": + result.push(await remove(o.refid, o.query, o.isPublicDoc)) + break + } + } catch (e) { + await log(new Date().toLocaleString() + " Error: " + (e as Error).message) + } + } + return result + } + + export async function removeAllData(refid?: string, filter?: string) { + for (let c of await getCollectionNames(filter)) remove(refid, { collection: c.name }) + + if ((refid == null) && (filter == null)) remove(null, { collection: "dbManager.collectionName" }) + } + export async function overall(refid: string, userId: number, filter: string, operation: "delete" | "export" | "override", data?: any) { + if (refid == null) return + try { + let collections = await DBM.getCollectionNames(filter) + let traverse = async (f: (rid: string | null, query: Query>) => Promise) => { + let result = [] + for (let c of collections) { + if (c.name.includes("#userId") && (userId != null)) result.concat(...await f(null, { collection: c.name, userId: userId })) + else result.concat(...await f(refid, { collection: c.name })) + } + return result + } + switch (operation) { + case "delete": + await traverse((rid, query) => DBM.remove(rid, query)) + break + case "export": + let result = await traverse((rid, query) => DB.Find(rid, query)) + return JSON.stringify(result) + case "override": + if (!Array.isArray(data)) return "The data may not be an Asphyxia CORE savedata." + await traverse((rid, query) => DBM.remove(rid, query)) + for (let d of data) if ((typeof (d?.collection) == "string") && (!d.collection.includes(filter))) DB.Insert(d) + break + } + } catch (e) { + return e.message + } + return null + + } +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/utility/initialize.ts b/bst@asphyxia/handlers/utility/initialize.ts new file mode 100644 index 0000000..fb29364 --- /dev/null +++ b/bst@asphyxia/handlers/utility/initialize.ts @@ -0,0 +1,15 @@ +import { initializeBatch } from "./batch_initialize" +import { IPluginVersion } from "../../models/utility/plugin_version" +import { isHigherVersion } from "../../utility/utility_functions" +import { Batch } from "./batch" +import { DBM } from "./db_manager" +import { version } from "../../utility/about" + +export async function initialize() { + let oldVersion = await DB.FindOne({ collection: "bst.pluginVersion" }) + if ((oldVersion == null) || isHigherVersion(oldVersion.version, version)) { + initializeBatch() + await Batch.execute(version) + await DBM.upsert(null, { collection: "bst.pluginVersion" }, { collection: "bst.pluginVersion", version: version }) + } +} \ No newline at end of file diff --git a/bst@asphyxia/handlers/utility/webui.ts b/bst@asphyxia/handlers/utility/webui.ts new file mode 100644 index 0000000..ba51199 --- /dev/null +++ b/bst@asphyxia/handlers/utility/webui.ts @@ -0,0 +1,12 @@ +import { IWebUIMessage, WebUIMessageType } from "../../models/utility/webui_message" +import { DBM } from "./db_manager" + +export namespace UtilityHandlersWebUI { + export function pushMessage(message: string, version: number, type: WebUIMessageType, rid?: string) { + DBM.upsert(null, { collection: "utility.webuiMessage" }, { collection: "utility.webuiMessage", message: message, type: type, refid: rid, version: version }) + } + + export const removeWebUIMessage = async () => { + await DBM.remove(null, { collection: "utility.webuiMessage" }) + } +} \ No newline at end of file diff --git a/bst@asphyxia/index.ts b/bst@asphyxia/index.ts new file mode 100644 index 0000000..6d5d994 --- /dev/null +++ b/bst@asphyxia/index.ts @@ -0,0 +1,32 @@ +import { UtilityHandlersCommon } from "./handlers/utility/common" +import { UtilityHandlersWebUI } from "./handlers/utility/webui" +import { initialize } from "./handlers/utility/initialize" +import { Bst2HandlersCommon } from "./handlers/bst2/common" +import { Bst2HandlersWebUI } from "./handlers/bst2/webui" + +export function register() { + R.GameCode("NBT") + + routeBst2() + + R.WebUIEvent("removeWebUIMessage", UtilityHandlersWebUI.removeWebUIMessage) + + R.Unhandled() + + initialize() +} + +function routeBst2() { + R.Route("info2.common", Bst2HandlersCommon.Common) + R.Route("pcb2.boot", Bst2HandlersCommon.BootPcb) + R.Route("player2.start", Bst2HandlersCommon.StartPlayer) + R.Route("player2.continue", Bst2HandlersCommon.StartPlayer) + R.Route("player2.succeed", Bst2HandlersCommon.PlayerSucceeded) + R.Route("player2.read", Bst2HandlersCommon.ReadPlayer) + R.Route("player2.write", Bst2HandlersCommon.WritePlayer) + R.Route("player2.stagedata_write", Bst2HandlersCommon.WriteStageLog) + R.Route("player2.course_stage_data_write", Bst2HandlersCommon.WriteCourseStageLog) + R.Route("player2.course_data_write", Bst2HandlersCommon.WriteCourseLog) + + R.WebUIEvent("bst2UpdateSettings", Bst2HandlersWebUI.UpdateSettings) +} \ No newline at end of file diff --git a/bst@asphyxia/models/bst2/event_params.ts b/bst@asphyxia/models/bst2/event_params.ts new file mode 100644 index 0000000..4433dba --- /dev/null +++ b/bst@asphyxia/models/bst2/event_params.ts @@ -0,0 +1,47 @@ +import { BigIntProxy, boolme, KITEM2, KM, s32me, u64me } from "../../utility/mapping" + +export interface IFloorInfectionEventParams { + id: number + musicList: number + isCompleted: boolean +} +export const FloorInfectionEventParamsMap: KM = { + id: s32me("infection_id", 20), + musicList: s32me("music_list", 7), + isCompleted: boolme("is_complete", true) +} + +export interface IBst2EventParams { + playerId: number + startTime: bigint | BigIntProxy + hasRbCollaboration: boolean + hasPopnCollaboration: boolean + floorInfection: { event: IFloorInfectionEventParams } + museca: { isPlayedMuseca: boolean } +} +export const Bst2EventParamsMap: KM = { + playerId: s32me("plyid"), + startTime: u64me("start_time"), + hasRbCollaboration: boolme("reflec_collabo", true), + hasPopnCollaboration: boolme("pop_collabo", true), + floorInfection: { event: FloorInfectionEventParamsMap, $targetKey: "floor_infection" }, + museca: { isPlayedMuseca: boolme("is_play_museca", true) }, +} + +export interface IBst2EventControl { + type: number + phase: number +} +export const Bst2EventControlMap: KM = { + type: s32me(), + phase: s32me() +} + +let kEventControl: KITEM2[] +export function getKEventControl(): KITEM2[] { + if (kEventControl == null) { + kEventControl = [] + for (let i = 0; i <= 40; i++) for (let j = 0; j <= 25; j++) kEventControl.push({ type: K.ITEM("s32", i), phase: K.ITEM("s32", j) }) + } + return kEventControl +} \ No newline at end of file diff --git a/bst@asphyxia/models/bst2/profile.ts b/bst@asphyxia/models/bst2/profile.ts new file mode 100644 index 0000000..13103cb --- /dev/null +++ b/bst@asphyxia/models/bst2/profile.ts @@ -0,0 +1,263 @@ +import { BigIntProxy, boolme, colme, ignoreme, KM, s16me, s32me, s8me, strme, u16me, u64me, u8me } from "../../utility/mapping" +import { FixedSizeArray } from "../../utility/type" +import { ICollection } from "../utility/definitions" + +export interface IBst2Account extends ICollection<"bst.bst2.player.account"> { + userId: number + isTakeOver: number + playerId: number + continueCount: number + playCount: number + playCountToday: number + crd: number + brd: number + dayCount: number + refid: string + lobbyId: string + mode: number + version: number + pp: boolean + ps: boolean + pay: number + payedPlayCount: number + standardTime: bigint | BigIntProxy + intrvld?: number + previousStartTime?: bigint | BigIntProxy + ea?: boolean +} +export const Bst2AccountMap: KM = { + collection: colme("bst.bst2.player.account"), + userId: s32me("usrid"),// + isTakeOver: s32me("is_takeover"),// + playerId: s32me("plyid"), + continueCount: s32me("continue_cnt"), + playCount: s32me("tpc"),// + playCountToday: s32me("dpc"),// + crd: s32me(),// + brd: s32me(),// + dayCount: s32me("tdc"),// + refid: strme("rid"), + lobbyId: strme("lid", "Asphyxia"), + mode: u8me(null, 2), + version: s16me("ver"),// + pp: boolme(), + ps: boolme(), + pay: s16me(), + payedPlayCount: s16me("pay_pc"), + standardTime: u64me("st", BigInt(Date.now())),// + intrvld: s32me(),// + previousStartTime: u64me("pst"),// + ea: boolme()// +} + +export interface IBst2Base extends ICollection<"bst.bst2.player.base"> { + name: string + brnk: number + bcnum: number + lcnum: number + volt: number + gold: number + lastMusicId: number + lastChart: number + lastSort: number + lastTab: number + splv: number + preference: number + lcid: number + hat: number +} +export const Bst2BaseMap: KM = { + collection: colme("bst.bst2.player.base"), + name: strme(), + brnk: s8me(), + bcnum: s8me(), + lcnum: s8me(), + volt: s32me(), + gold: s32me(), + lastMusicId: s32me("lmid"), + lastChart: s8me("lgrd"), + lastSort: s8me("lsrt"), + lastTab: s8me("ltab"), + splv: s8me(), + preference: s8me("pref"), + lcid: s32me(), + hat: s32me() +} + +export interface IBst2Survey extends ICollection<"bst.bst2.player.survey"> { + motivate: number +} +export const Bst2SurveyMap: KM = { + collection: colme("bst.bst2.player.survey"), + motivate: s8me() +} + +export interface IBst2UnlockingInfo extends ICollection<"bst.bst2.player.unlockingInfo"> { + type: number + id: number + param: number + count: number +} +export const Bst2UnlockingInfoMap: KM = { + collection: colme("bst.bst2.player.unlockingInfo"), + type: s32me(), + id: s32me(), + param: s32me(), + count: s32me() +} + +export interface IBst2Customization extends ICollection<"bst.bst2.player.customization"> { + // [rippleNote, rippleNoteColor, sfxNormalNote, sfxRippleNote, sfxSlashNote, sfxStreamNote, backgroundBrightnessTimes2, (000{sfxFine}{sfxStreamTail}{streamNoteGuide}{rippleNoteGuide}{judgeText}, ?, ?, ?, ?, ?, ?, ?, ?)] + custom: FixedSizeArray +} +export const Bst2CustomizationMap: KM = { + collection: colme("bst.bst2.player.customization"), + custom: u16me(null, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) +} + +export interface IBst2Tips extends ICollection<"bst.bst2.player.tips"> { + lastTips: number +} +export const Bst2TipsMap: KM = { + collection: colme("bst.bst2.player.tips"), + lastTips: s32me("last_tips") +} + +export interface IBst2Hacker extends ICollection<"bst.bst2.player.hacker"> { + id: number + state0: number + state1: number + state2: number + state3: number + state4: number + updateTime: bigint | BigIntProxy +} +export const Bst2HackerMap: KM = { + collection: colme("bst.bst2.player.hacker"), + id: s32me(), + state0: s8me(), + state1: s8me(), + state2: s8me(), + state3: s8me(), + state4: s8me(), + updateTime: u64me("update_time") +} + +export interface IBst2CrysisLog extends ICollection<"bst.bst2.player.event.crysis"> { + id: number + stageId: number + step: number + gauge: number + state: number +} +export const Bst2CrysisLogMap: KM = { + collection: colme("bst.bst2.player.event.crysis"), + id: s32me(), + stageId: s32me("stage_no"), + step: s8me(), + gauge: s32me("r_gauge"), + state: s8me("r_state") +} + +export interface IBst2Bisco extends ICollection<"bst.bst2.player.bisco"> { + bnum: number + jbox: number +} +export const Bst2BiscoMap: KM = { + collection: colme("bst.bst2.player.bisco"), + bnum: s32me(), + jbox: s32me(), +} + +export interface IBst2MusicRecord extends ICollection<"bst.bst2.playData.musicRecord#userId"> { + musicId: number + chart: number + playCount: number + clearCount: number + gaugeTimes10: number + score: number + grade: number + medal: number + combo: number + userId: number + updateTime: number + lastPlayTime: number +} +export const Bst2MusicRecordMap: KM = { + collection: colme("bst.bst2.playData.musicRecord#userId"), + musicId: s32me("music_id"), + chart: s32me("note_level"), + playCount: s32me("play_count"), + clearCount: s32me("clear_count"), + gaugeTimes10: s32me("best_gauge"), + score: s32me("best_score"), + grade: s32me("best_grade"), + medal: s32me("best_medal"), + combo: ignoreme(), + userId: ignoreme(), + updateTime: ignoreme(), + lastPlayTime: ignoreme() +} + +export interface IBst2Course extends ICollection<"bst.bst2.playData.course#userId"> { + courseId: number + playCount: number + isTouched: boolean + clearType: number + gauge: number + score: number + grade: number + medal: number + combo: number + userId: number + updateTime: number + lastPlayTime: number +} +export const Bst2CourseMap: KM = { + collection: colme("bst.bst2.playData.course#userId"), + courseId: s32me("course_id"), + playCount: s32me("play"), + isTouched: boolme("is_touch"), + clearType: s32me("clear"), + gauge: s32me("gauge"), + score: s32me(), + grade: s32me(), + medal: s32me(), + combo: s32me(), + userId: ignoreme(), + updateTime: ignoreme(), + lastPlayTime: ignoreme() +} + +export interface IBst2Player { + pdata: { + account: IBst2Account + base: IBst2Base + opened: {} + survey: IBst2Survey + item: { info?: IBst2UnlockingInfo[] } + customize: IBst2Customization + tips: IBst2Tips + hacker: { info?: IBst2Hacker[] } + playLog: { crysis?: IBst2CrysisLog[] } + bisco: { pinfo: IBst2Bisco } + record: { rec?: IBst2MusicRecord[] } + course: { record?: IBst2Course[] } + } +} +export const Bst2PlayerMap: KM = { + pdata: { + account: Bst2AccountMap, + base: Bst2BaseMap, + opened: {}, + survey: Bst2SurveyMap, + item: { info: { 0: Bst2UnlockingInfoMap } }, + customize: Bst2CustomizationMap, + tips: Bst2TipsMap, + hacker: { info: { 0: Bst2HackerMap } }, + playLog: { crysis: { 0: Bst2CrysisLogMap }, $targetKey: "play_log" }, + bisco: { pinfo: Bst2BiscoMap }, + record: { rec: { 0: Bst2MusicRecordMap } }, + course: { record: { 0: Bst2CourseMap } } + } +} \ No newline at end of file diff --git a/bst@asphyxia/models/bst2/stagelog.ts b/bst@asphyxia/models/bst2/stagelog.ts new file mode 100644 index 0000000..f0d15ba --- /dev/null +++ b/bst@asphyxia/models/bst2/stagelog.ts @@ -0,0 +1,80 @@ +import { colme, ignoreme, KM, s32me, strme } from "../../utility/mapping" +import { ICollection } from "../utility/definitions" + +export interface IBst2StageLog extends ICollection<"bst.bst2.playData.stageLog#userId"> { + playerId: number + continueCount: number + stageId: number + userId: number + lobbyId: string + musicId: number + chart: number + gaugeTimes10: number + score: number + combo: number + grade: number + medal: number + fantasticCount: number + greatCount: number + fineCount: number + missCount: number + isCourseStage: boolean + time: number +} +export const Bst2StageLogMap: KM = { + collection: colme("bst.bst2.playData.stageLog#userId"), + playerId: s32me("play_id"), + continueCount: s32me("continue_count"), + stageId: s32me("stage_no"), + userId: s32me("user_id"), + lobbyId: strme("location_id"), + musicId: s32me("select_music_id"), + chart: s32me("select_grade"), + gaugeTimes10: s32me("result_clear_gauge"), + score: s32me("result_score"), + combo: s32me("result_max_combo"), + grade: s32me("result_grade"), + medal: s32me("result_medal"), + fantasticCount: s32me("result_fanta"), + greatCount: s32me("result_great"), + fineCount: s32me("result_fine"), + missCount: s32me("result_miss"), + isCourseStage: ignoreme(), + time: ignoreme(), +} + +export interface IBst2CourseLog extends ICollection<"bst.bst2.playData.courseLog#userId"> { + playerId: number + continueCount: number + userId: number + courseId: number + gauge: number + score: number + grade: number + medal: number + combo: number + fantasticCount: number + greatCount: number + fineCount: number + missCount: number + lobbyId: string + time: number +} +export const Bst2CourseLogMap: KM = { + collection: colme("bst.bst2.playData.courseLog#userId"), + playerId: s32me("play_id"), + continueCount: s32me("continue_count"), + userId: s32me("user_id"), + courseId: s32me("course_id"), + lobbyId: strme("lid"), + gauge: s32me(), + score: s32me(), + combo: s32me(), + grade: s32me(), + medal: s32me(), + fantasticCount: s32me("fanta"), + greatCount: s32me("great"), + fineCount: s32me("fine"), + missCount: s32me("miss"), + time: ignoreme() +} diff --git a/bst@asphyxia/models/utility/batch.ts b/bst@asphyxia/models/utility/batch.ts new file mode 100644 index 0000000..0147f43 --- /dev/null +++ b/bst@asphyxia/models/utility/batch.ts @@ -0,0 +1,5 @@ +import { ICollection } from "./definitions" + +export interface IBatchResult extends ICollection<"bst.batchResult"> { + batchId: string +} \ No newline at end of file diff --git a/bst@asphyxia/models/utility/definitions.d.ts b/bst@asphyxia/models/utility/definitions.d.ts new file mode 100644 index 0000000..820dde0 --- /dev/null +++ b/bst@asphyxia/models/utility/definitions.d.ts @@ -0,0 +1,3 @@ +export interface ICollection { + collection: TCollectionName +} \ No newline at end of file diff --git a/bst@asphyxia/models/utility/plugin_version.ts b/bst@asphyxia/models/utility/plugin_version.ts new file mode 100644 index 0000000..0a12446 --- /dev/null +++ b/bst@asphyxia/models/utility/plugin_version.ts @@ -0,0 +1,5 @@ +import { ICollection } from "./definitions" + +export interface IPluginVersion extends ICollection<"bst.pluginVersion"> { + version: string +} \ No newline at end of file diff --git a/bst@asphyxia/models/utility/webui_message.ts b/bst@asphyxia/models/utility/webui_message.ts new file mode 100644 index 0000000..7acc3ec --- /dev/null +++ b/bst@asphyxia/models/utility/webui_message.ts @@ -0,0 +1,14 @@ +import { ICollection } from "./definitions" + +export interface IWebUIMessage extends ICollection<"utility.webuiMessage"> { + message: string + type: WebUIMessageType + refid?: string + version: number +} + +export enum WebUIMessageType { + info = 0, + success = 1, + error = 2 +} \ No newline at end of file diff --git a/bst@asphyxia/utility/about.ts b/bst@asphyxia/utility/about.ts new file mode 100644 index 0000000..2221fdd --- /dev/null +++ b/bst@asphyxia/utility/about.ts @@ -0,0 +1,4 @@ +export type Game = "bst" +export const game: Game = "bst" +export type PluginVersion = "1.0.0" +export const version: PluginVersion = "1.0.0" diff --git a/bst@asphyxia/utility/mapping.ts b/bst@asphyxia/utility/mapping.ts new file mode 100644 index 0000000..521cdcb --- /dev/null +++ b/bst@asphyxia/utility/mapping.ts @@ -0,0 +1,480 @@ +import { ICollection } from "../models/utility/definitions" + +export type KArrayType = KNumberType | KBigIntType +export type KGroupType = KNumberGroupType | KBigIntGroupType +export type KType = KArrayType | KGroupType | "str" | "bin" | "ip4" | "bool" +export type KTypeExtended = KType | null | "kignore" +export type TypeForKItem = number | string | bigint | BigIntProxy | boolean | Buffer | number[] | bigint[] | boolean[] | BufferArray | NumberGroup +export type TypeForKObject = T extends TypeForKItem ? never : T +export type TypeForKArray = number[] | bigint[] | BufferArray + +export type KKey = keyof T & ( + T extends string ? Exclude : + T extends Buffer ? Exclude : + T extends boolean ? Exclude : + T extends number[] | bigint[] | boolean[] ? Exclude : + T extends any[] ? Exclude | number : + T extends number ? Exclude : + T extends bigint | BigIntProxy ? Exclude : + T extends BufferArray ? Exclude : + T extends NumberGroup ? Exclude> : + keyof T) + +export type KTypeConvert = + T extends string ? "str" : + T extends Buffer ? "bin" : + T extends number ? KNumberType | "ip4" | "bool" : + T extends bigint | BigIntProxy ? KBigIntType : + T extends boolean | boolean[] ? "bool" : + T extends number[] ? KNumberType : // KARRAY + T extends bigint[] ? KBigIntType : // KARRAY + T extends NumberGroup ? KNumberGroupType : + T extends NumberGroup ? KBigIntGroupType : + T extends BufferArray ? "u8" | "s8" : + never + +export type KArrayTypeConvert = + T extends Buffer ? "s8" | "u8" : + T extends number[] ? KNumberType : + T extends bigint[] ? KBigIntType : + never + +export type KTypeConvertBack = + TKType extends "str" ? string : + TKType extends "bin" ? { type: "Buffer"; data: number[] } : + TKType extends "s8" | "u8" ? [number] | number[] | { type: "Buffer"; data: number[] } : + TKType extends KNumberType ? [number] | number[] : + TKType extends KBigIntType ? [bigint] | bigint[] : + TKType extends KNumberGroupType ? number[] : + TKType extends KBigIntGroupType ? bigint[] : + unknown + +export type NumberGroup = { + "@numberGroupValue": T +} +export const NumberGroup = (ng: T) => { "@numberGroupValue": ng } +export function isNumberGroup(value: any): value is NumberGroup { + try { + return Array.isArray(BigInt(value["@numberGroupValue"])) + } catch { + return false + } +} +export type BufferArray = { + "@bufferArrayValue": Buffer +} +export const BufferArray = (ba: Buffer) => { "@bufferArrayValue": ba } +export function isBufferArray(value: any): value is BufferArray { + try { + return value["@bufferArrayValue"] instanceof Buffer + } catch { + return false + } +} +export type BigIntProxy = { + "@serializedBigInt": string +} +export const BigIntProxy = (value: bigint) => { "@serializedBigInt": value.toString() } +export function isBigIntProxy(value: any): value is BigIntProxy { + try { + return BigInt(value["@serializedBigInt"]).toString() == value["@serializedBigInt"] + } catch { + return false + } +} +export function toBigInt(value: bigint | BigIntProxy): bigint { + if (value == null) return null + if (value instanceof BigInt) return value + else if (value["@serializedBigInt"] != null) return BigInt(value["@serializedBigInt"]) + else return BigInt(0) +} + +export type KITEM2 = { [K in keyof T]?: K extends KKey ? KITEM2 : never } & +{ + ["@attr"]: KAttrMap2 + ["@content"]: + T extends string | Buffer | boolean | number[] | bigint[] ? T : + T extends number | bigint ? [T] : + T extends BufferArray ? Buffer : + T extends NumberGroup ? TGroup : + T extends BigIntProxy ? [bigint] : never +} + +export type KAttrMap2 = { [key: string]: string } & { + __type?: T extends TypeForKItem ? KTypeConvert : never + __count?: T extends TypeForKArray ? number : never +} + +export function ITEM2(ktype: KTypeConvert, value: T, attr?: KAttrMap2): KITEM2 { + // let result + // if (value instanceof NumberGroup && IsNumberGroupKType(ktype)) { + // result = K.ITEM(>ktype, value.value, attr) + // } else if (Array.isArray(value) && IsNumericKType(ktype)) { + // result = K.ARRAY(>ktype, value, attr) + // } else if (value instanceof BufferArray && IsNumericKType(ktype)) { + // result = K.ARRAY(>ktype, value.value, attr) + // } else if (typeof value != "object" && typeof value != "function") { + // result = K.ITEM(ktype, value, attr) + // } else { + // Object.assign(result, value, { ["@attr"]: attr }) + // result["@attr"].__type = ktype + // } + + // return >result + let result = >{} + result["@attr"] = Object.assign({}, attr, (!isNumberGroupKType(ktype) && isNumericKType(ktype) && Array.isArray(value)) ? { __type: ktype, __count: (value).length } : { __type: ktype }) + + if ((ktype == "bool") && (typeof value == "boolean")) { + result["@content"] = (value ? [1] : [0]) + } else if ((ktype == "bin") && value instanceof Buffer) { + result = K.ITEM("bin", value, result["@attr"]) + } else if (((ktype == "s8") || (ktype == "u8")) && isBufferArray(value)) { + result["@content"] = value["@bufferArrayValue"].toJSON() + result["@attr"].__count = value["@bufferArrayValue"].byteLength + } else if (isNumericKType(ktype) && !Array.isArray(value)) { + result["@content"] = [value] + } else if (isNumberGroupKType(ktype) && isNumberGroup(value)) { + result["@content"] = value["@numberGroupValue"] + } else if (isBigIntProxy(value)) { + result["@content"] = BigInt(value["@serializedBigInt"]) + } + else { + result["@content"] = value + } + if (isKIntType(ktype) && Array.isArray(result["@content"])) for (let i = 0; i < result["@content"].length; i++) (result["@content"])[i] = Math.trunc(result["@content"][i]) + return result +} + +export type KObjectMappingRecord = { [K in KKey]: T[K] extends TypeForKItem ? KObjectMappingElementInfer : KObjectMappingRecord } & KObjectMappingElementInfer +export interface KObjectMappingElement { + $type?: TKType, + $targetKey?: string, + $convert?: (source: T) => T + $convertBack?: (target: T) => T + $fallbackValue?: TKType extends "kignore" ? T : never + $defaultValue?: T +} +type KObjectMappingElementInfer = KObjectMappingElement extends KType ? KTypeConvert : never) | never | "kignore"> + +export type KAttrRecord = { [K in keyof T]?: T extends TypeForKItem ? KAttrMap2 : KAttrRecord } & { selfAttr?: KAttrMap2 } + +export function getCollectionMappingElement>(collectionName: TCollection extends ICollection ? TName : never): KObjectMappingElement ? TName : unknown, "kignore"> { + return ignoreme("collection", collectionName) +} + +function isKType(type: TType): boolean { + return (typeof (type) == "string") && ["s8", "u8", "s16", "u16", "s32", "u32", "time", "ip4", "float", "double", "bool", "s64", "u64", "2s8", "2u8", "2s16", "2u16", "2s32", "2u32", "2f", "2d", "3s8", "3u8", "3s16", "3u16", "3s32", "3u32", "3f", "3d", "4s8", "4u8", "4s16", "4u16", "4s32", "4u32", "4f", "4d", "2b", "3b", "4b", "vb", "2s64", "2u64", "3s64", "3u64", "4s64", "4u64", "vs8", "vu8", "vs16", "vu16", "str", "bin"].includes(type) +} +function isKIntType(type: TType): boolean { + return (typeof (type) == "string") && ["s8", "u8", "s16", "u16", "s32", "u32", "2s8", "2u8", "2s16", "2u16", "2s32", "2u32", "3s8", "3u8", "3s16", "3u16", "3s32", "3u32", "4s8", "4u8", "4s16", "4u16", "4s32", "4u32", "2b", "3b", "4b", "vb", "vs8", "vu8", "vs16", "vu16"].includes(type) +} +function isKBigIntType(type: TType): boolean { + return (typeof (type) == "string") && ["s64", "u64"].includes(type) +} +function isNumericKType(type: TType): boolean { + return (typeof (type) == "string") && ["s8", "u8", "s16", "u16", "s32", "u32", "time", "ip4", "float", "double", "bool", "s64", "u64"].includes(type) +} +function isNumberGroupKType(type: TType): boolean { + return (typeof (type) == "string") && ["2s8", "2u8", "2s16", "2u16", "2s32", "2u32", "2f", "2d", "3s8", "3u8", "3s16", "3u16", "3s32", "3u32", "3f", "3d", "4s8", "4u8", "4s16", "4u16", "4s32", "4u32", "4f", "4d", "2b", "3b", "4b", "vb", "2s64", "2u64", "3s64", "3u64", "4s64", "4u64", "vs8", "vu8", "vs16", "vu16"].includes(type) +} +function isNumericKey(k: any): boolean { + return (typeof k == "number") || (parseInt(k).toString() == k) +} +function increaseNumericKey(k: T, step: number = 1): T { + return (typeof k == "number") ? (k + step) : (typeof k == "string" && parseInt(k).toString() == k) ? (parseInt(k) + step) : k +} +function isEmptyKObject(o: object): boolean { + return (Object.keys(o).length == 0) || ((Object.keys(o).length == 1) && (o["@attr"] != null)) +} +function isKMapRecordReservedKey(key: string): boolean { + return ["$type", "$targetKey", "$convert", "$convertBack", "$fallbackValue", "$defaultValue"].includes(key) +} +function isKArray(data: KITEM2): boolean { + return (data["@attr"] != null) && (data["@attr"].__count != null) +} + +export function appendMappingElement(map: KObjectMappingRecord, element: KObjectMappingElementInfer): KObjectMappingRecord { + let result = >{} + Object.assign(result, map, element) + return result +} + +export function mapKObject(data: T, kMapRecord: KObjectMappingRecord, kAttrRecord: KAttrRecord = >{}): KITEM2 { + if (data == null) return >{} + let result: KITEM2 = (((0 in data) && data instanceof Object) ? [] : {}) + if (kAttrRecord.selfAttr != null) result["@attr"] = kAttrRecord.selfAttr + + if (data instanceof Object) { + for (let __k in data) { + let k: keyof T = __k + let mapK: keyof T = __k + let attrK: keyof T = __k + if (!(k in kMapRecord) && isNumericKey(k)) { + for (let i = parseInt(k) - 1; i >= 0; i--) if (kMapRecord[i]) { + mapK = i + break + } + } + if (!(k in kAttrRecord) && isNumericKey(k)) { + for (let i = parseInt(k) - 1; i >= 0; i--) if (kAttrRecord[i]) { + attrK = i + break + } + } + if (mapK in kMapRecord) { + let target = [keyof T]>{} + let targetMap = kMapRecord[>mapK] + let targetKey: keyof T = (targetMap.$targetKey != null) ? targetMap.$targetKey : k + let targetValue = (targetMap.$convert != null) ? >>targetMap.$convert(data[k]) : data[k] + let targetAttr = kAttrRecord[attrK] + if (targetMap.$type) { + let tt = targetMap.$type + if (tt == "kignore") continue + target["@attr"] = Object.assign({}, targetAttr, (!isNumberGroupKType(tt) && isNumericKType(tt) && Array.isArray(data[k]) && Array.isArray(targetValue)) ? { __type: tt, __count: (targetValue).length } : { __type: tt }) + + if ((tt == "bool") && (typeof targetValue == "boolean")) { + target["@content"] = (targetValue ? [1] : [0]) + } else if ((tt == "bin") && targetValue instanceof Buffer) { + target = K.ITEM("bin", targetValue, target["@attr"]) + } else if (((tt == "s8") || (tt == "u8")) && isBufferArray(targetValue)) { + target["@content"] = targetValue["@bufferArrayValue"] + } else if (isNumericKType(tt) && !Array.isArray(targetValue)) { + target["@content"] = [targetValue] + } else if (isNumberGroupKType(tt) && isNumberGroup(targetValue)) { + target["@content"] = targetValue["@numberGroupValue"] + } else if (isBufferArray(targetValue)) { + target["@content"] = targetValue["@bufferArrayValue"].toJSON() + target["@attr"].__count = targetValue["@bufferArrayValue"].byteLength + } else if (isBigIntProxy(targetValue)) { + target["@content"] = BigInt(targetValue["@serializedBigInt"]) + } else { + target["@content"] = targetValue + } + if (isKIntType(tt) && Array.isArray(target["@content"])) for (let i = 0; i < target["@content"].length; i++) (target["@content"])[i] = Math.trunc(target["@content"][i]) + } else { + target = mapKObject(targetValue, >targetMap, >targetAttr) + } + result[targetKey] = target + } + } + } else result = ITEM2(>kAttrRecord.selfAttr.$type, data, kAttrRecord.selfAttr) + + return result +} + +export type MapBackResult = { + data: T, + attr?: KAttrRecord +} +export function mapBackKObject(data: KITEM2, kMapRecord?: KObjectMappingRecord): MapBackResult { + if (kMapRecord == null) { + if (data["@content"] || data["@attr"]) return { data: data["@content"], attr: data["@attr"] } + else return { data: data } + } + let result: T = ((Array.isArray(data) || 0 in kMapRecord) ? [] : {}) + let resultAttr: KAttrRecord = { selfAttr: data["@attr"] ? data["@attr"] : null } + + for (let __k in kMapRecord) { + if (isKMapRecordReservedKey(__k)) continue + let k = __k + let preservK = __k + do { + let targetMap = kMapRecord[>preservK] + let targetKey = (targetMap.$targetKey ? targetMap.$targetKey : k) + let doOnceFlag = (isNumericKey(targetKey) && (data[targetKey] == null) && !isEmptyKObject(data)) + let targetValue = [keyof T]>(doOnceFlag ? data : data[targetKey]) + + if (targetMap.$type == "kignore") { + result[k] = targetMap.$fallbackValue + if ((targetValue != null) && (targetValue["@attr"] != null)) resultAttr[k] = [keyof T]>{ selfAttr: targetValue["@attr"] } + continue + } + + if (targetValue == null) { + if (targetMap.$convertBack != null) result[k] = targetMap.$convertBack(null) + continue + } + + if (targetValue["@attr"] != null) { + let targetAttr: KAttrMap2 = targetValue["@attr"] + let targetResult + + if (targetAttr.__type != null) { // KITEM + targetResult = targetValue["@content"] + if (isNumberGroupKType(targetAttr.__type)) { // KITEM2 + // TODO: bigint number group + targetResult = NumberGroup(targetResult) + } else if (targetAttr.__type == "bin") { // KITEM<"bin"> + targetResult = targetResult + } else if ((targetAttr.__type == "s8" || targetAttr.__type == "u8") && (targetResult?.type == "Buffer") && Array.isArray(targetResult?.data)) { // KITEM2 + targetResult = BufferArray(Buffer.from(targetResult.data)) + } else if (targetAttr.__type == "bool") { // KITEM<"bool"> + targetResult = targetResult[0] == 1 ? true : false + } else if (Array.isArray(targetResult) && (targetAttr.__count == null) && isNumericKType(targetAttr.__type)) { // KITEM + targetResult = ((targetAttr.__type == "s64") || (targetAttr.__type == "u64")) ? BigIntProxy(BigInt(targetResult[0])) : targetResult[0] + } + result[k] = (targetMap.$convertBack != null) ? targetMap.$convertBack(targetResult) : targetResult + } else { // KObject + targetResult = (targetMap.$convertBack != null) ? targetMap.$convertBack(targetValue) : targetValue; + let partial = mapBackKObject(targetResult, targetMap) + result[k] = partial.data + resultAttr[k] = partial.attr + } + } else { // KObject + let targetResult = (targetMap.$convertBack != null) ? targetMap.$convertBack(targetValue) : targetValue; + let partial = mapBackKObject(targetResult, targetMap) + result[k] = partial.data + resultAttr[k] = partial.attr + } + k = increaseNumericKey(k) + if (doOnceFlag || (isNumericKey(k) && (data[(targetMap.$targetKey ? targetMap.$targetKey : k)] == null))) break + } while (isNumericKey(k) && !(k in kMapRecord)) + } + return { data: result, attr: resultAttr } +} + +export function s8me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "s8", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function u8me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "u8", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function s16me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "s16", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function u16me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "u16", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function s32me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "s32", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function u32me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "u32", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function s64me(targetKey?: string, defaultValue?: bigint | BigIntProxy, convert?: (source: bigint | BigIntProxy) => bigint | BigIntProxy, convertBack?: (target: bigint | BigIntProxy) => bigint | BigIntProxy): KObjectMappingElement { + return { + $type: "s64", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function u64me(targetKey?: string, defaultValue?: bigint | BigIntProxy, convert?: (source: bigint | BigIntProxy) => bigint | BigIntProxy, convertBack?: (target: bigint | BigIntProxy) => bigint | BigIntProxy): KObjectMappingElement { + return { + $type: "u64", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} + +export function boolme(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $type: "bool", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export function strme(targetKey?: string, defaultValue?: TName, convert?: (source: TName) => TName, convertBack?: (target: TName) => TName): KObjectMappingElement { + return { + $type: "str", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} + +export function binme(targetKey?: string, defaultValue?: Buffer, convert?: (source: Buffer) => Buffer, convertBack?: (target: Buffer) => Buffer): KObjectMappingElement { + return { + $type: "bin", + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} + +export function ignoreme(targetKey?: string, fallbackValue?: T): KObjectMappingElement { + return { + $type: "kignore", + $fallbackValue: fallbackValue + } +} +export function me(targetKey?: string, defaultValue?: T, convert?: (source: T) => T, convertBack?: (target: T) => T): KObjectMappingElement { + return { + $targetKey: targetKey, + $convert: convert, + $convertBack: convertBack, + $defaultValue: defaultValue + } +} +export const colme = getCollectionMappingElement +export const appendme = appendMappingElement +export const mapK = mapKObject +export const bacK = mapBackKObject + +export function fromMap(map: KObjectMappingRecord): T { + let result = {} + if (map.$type == "kignore") return map.$fallbackValue + if (map.$defaultValue != null) return map.$defaultValue + if (map.$type != null) { + if (isNumericKType(map.$type)) { + if (map.$type == "bool") return false + else return 0 + } else if (isKBigIntType(map.$type)) return BigInt(0) + else if (isNumberGroupKType(map.$type)) return NumberGroup([0]) + else if (map.$type == "str") return "" + + else return null + } + for (let k in map) { + if (isKMapRecordReservedKey(k)) continue + let value = fromMap(map[k]) + if (value != null) result[k] = value + } + + return result +} + +export type KM = KObjectMappingRecord \ No newline at end of file diff --git a/bst@asphyxia/utility/type.ts b/bst@asphyxia/utility/type.ts new file mode 100644 index 0000000..1140875 --- /dev/null +++ b/bst@asphyxia/utility/type.ts @@ -0,0 +1,4 @@ +export type FixedSizeArray = [T, ...T[]] & { readonly length: TSize } +export function fillArray(size: TSize, fillValue: T): FixedSizeArray { + return Array(size).fill(fillValue) +} \ No newline at end of file diff --git a/bst@asphyxia/utility/utility_functions.ts b/bst@asphyxia/utility/utility_functions.ts new file mode 100644 index 0000000..c5b6851 --- /dev/null +++ b/bst@asphyxia/utility/utility_functions.ts @@ -0,0 +1,67 @@ +export function toFullWidth(s: string): string { + let resultCharCodes: number[] = [] + for (let i = 0; i < s.length; i++) { + let cc = s.charCodeAt(i) + if ((cc >= 33) && (cc <= 126)) resultCharCodes.push(cc + 65281 - 33) + else if (cc == 32) resultCharCodes.push(12288) // Full-width space + else resultCharCodes.push(cc) + } + return String.fromCharCode(...resultCharCodes) +} +export function toHalfWidth(s: string): string { + let resultCharCodes: number[] = [] + for (let i = 0; i < s.length; i++) { + let cc = s.charCodeAt(i) + if ((cc >= 65281) && (cc <= 65374)) resultCharCodes.push(cc - 65281 + 33) + else if (cc == 12288) resultCharCodes.push(32) // Full-width space + else resultCharCodes.push(cc) + } + return String.fromCharCode(...resultCharCodes) +} +export function isToday(st: bigint): boolean { + let now = new Date() + let today = new Date(now.getFullYear(), now.getMonth(), now.getDate()) + let tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1) + return (st >= (today.valueOf())) && (st < (tomorrow.valueOf())) +} +export async function log(data: any, file?: string) { + if (file == null) file = "./log.txt" + let s = IO.Exists(file) ? await IO.ReadFile(file, "") : "" + if (typeof data == "string") s += data + "\n" + else { + let n = "" + try { + n = JSON.stringify(data) + } catch { } + s += n + "\n" + } + await IO.WriteFile(file, s) +} +export function base64ToBuffer(str: string, size?: number): Buffer { + if (size != null) { + let rem = size - Math.trunc(size / 3) * 3 + str = str.replace("=", "A").replace("=", "A").padEnd(Math.trunc(size / 3) * 4 + rem + 1, "A") + if (rem == 1) str += "==" + else if (rem == 2) str += "=" + let result = Buffer.alloc(size, str, "base64") + return result + } + else return Buffer.from(str, "base64") +} +export function bufferToBase64(buffer: Buffer, isTrimZero: boolean = true): string { + if (isTrimZero) for (let i = buffer.length - 1; i >= 0; i--) if (buffer.readInt8(i) != 0) return buffer.toString("base64", 0, i + 1) + return buffer.toString("base64") +} +export function isHigherVersion(left: string, right: string): boolean { + let splitedLeft = left.split(".") + let splitedRight = right.split(".") + + if (parseInt(splitedLeft[0]) < parseInt(splitedRight[0])) return true + else if (parseInt(splitedLeft[0]) == parseInt(splitedRight[0])) { + if (parseInt(splitedLeft[1]) < parseInt(splitedRight[1])) return true + else if (parseInt(splitedLeft[1]) == parseInt(splitedRight[1])) { + if (parseInt(splitedLeft[2]) < parseInt(splitedRight[2])) return true + } + } + return false +} diff --git a/bst@asphyxia/webui/css/webui_util.css b/bst@asphyxia/webui/css/webui_util.css new file mode 100644 index 0000000..5bfec78 --- /dev/null +++ b/bst@asphyxia/webui/css/webui_util.css @@ -0,0 +1,243 @@ +#tab-content, .tab-content { + display: none; +} + +#tab-content.is-active, .tab-content.is-active { + display: block; +} + +tr#tab-content.is-active, tr.tab-content.is-active { + display: table-row; +} + +#tabs li.disabled a { + background-color: #c0c0c0; + border-color: #c0c0c0; + color: #7f7f7f; + cursor: default; +} + +#form-pagination ul.pagination-list { + margin: 0!important; +} +.pagination-link, .pagination-next, .pagination-previous { + border-color: transparent; + transition: .2s linear; +} +.pagination-next, .pagination-previous { + color: #209CEE; +} +.pagination-next:not([disabled]):hover, .pagination-previous:not([disabled]):hover { + color: #118fe4; +} +/* Set all link color to Asphyxia CORE blue */ +::selection { + color: white; + background-color: #209CEE; +} +a { + color: #209CEE; +} +.tabs.is-toggle li.is-active a { + background-color: #209CEE; + border-color: #209CEE; +} +.tabs li.is-active a { + color: #209CEE; + border-color: #209CEE; +} +.pagination-link.is-current { + background-color: #209CEE; + border-color: #209CEE; + cursor: default; +} +.select:not(.is-multiple):not(.is-loading):after { + border-color: #209CEE; +} +.select select:active, .select select:focus { + border-color: #209CEE; +} +.button.is-link { + background-color: #209CEE; +} +.button.is-link.is-active, .button.is-link:active, .button.is-link.is-hovered, .button.is-link:hover { + background-color: #118fe4; +} +.input:active, .input:focus { + border-color: #209CEE; +} +.table tr.is-selected { + background-color: #209CEE; +} + +#card-content.is-hidden { + display: none; +} +#card-content { + display: block; +} +.marquee-label { + display: inline-block; +} +.marquee-label-container { + overflow-x: hidden; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + vertical-align: middle; +} + +/* from Bulma */ +.button.is-danger.is-light { + background-color: #feecf0; + color: #cc0f35; +} +.button.is-link.is-light { + background-color: #edf8ff; + color: #209CEE; +} +.button.is-danger.is-light.is-hovered, .button.is-danger.is-light:hover { + background-color: #fde0e6; + color: #cc0f35; +} +.button.is-link.is-light.is-hovered, .button.is-link.is-light:hover { + background-color: #e0f1fc; + color: #209CEE; +} +.tag.is-link.is-light { + background-color: #edf8ff; + color: #0D7DC6; +} +.tag.is-link.is-light:hover { + background-color: #209CEE; + color: white; +} +.tag.is-delete:hover { + background-color: #FF3860!important; + color: white; +} + +@media screen and (max-width: 768px) { + .pagination { + flex-wrap: nowrap; + justify-content: left; + } +} +.pagination-list { + flex-wrap: nowrap; + list-style: none!important; + margin-top: 0.25em!important; + margin-bottom: 0.25em!important; +} + +.content li + li { + margin-top: 0; +} + +.one-quarter#forwide, .one-third#forwide { + display: block; + min-width: 100px; +} +.one-quarter#fornarrow, .one-third#fornarrow { + display: none; + min-width: 50px; +} +@media only screen and (max-width: 1023px) { + .one-quarter#forwide { + display: none; + } + .one-quarter#fornarrow { + display: block; + } +} +@media only screen and (max-width: 700px) { + .one-third#forwide { + display: none; + } + .one-third#fornarrow { + display: block; + } +} + + +@keyframes notification-fadeout { + 0% { + opacity: 1; + display: block; + } + 80% { + opacity: 1; + display: block; + } + 99.99% { + opacity: 0; + display: block; + } + 100% { + opacity: 0; + display: none; + } +} + +.notification { + animation: notification-fadeout 8s forwards; + animation-play-state: paused; +} +.notification:hover { + animation-play-state: paused; +} +.modal { + padding-bottom: 13px; +} +@media screen and (max-width:1024px) { + .modal { + transition: padding-left .2s ease-in-out 50ms; + } +} +@media screen and (min-width:1023px) { + .modal { + padding-left: 256px; + transition: padding-left .2s ease-in-out 50ms; + } +} +.tag { + transition: linear .2s; +} +.tags .tag:not(:last-child) { + cursor: default; +} + +.modal table tr { + border: solid #dbdbdb; + border-width: 0 0 1px; +} +.modal table tbody tr:last-child { + border-bottom-width: 0; +} +.hidden-wrapper { + overflow: hidden; +} +.hidden-x-wrapper { + overflow-x: hidden; +} +.hidden-y-wrapper { + overflow-y: hidden; +} +.scrolling-wrapper { + overflow: auto; +} +.scrolling-x-wrapper { + overflow-x: auto; +} +.scrolling-y-wrapper { + overflow-y: auto; +} +a.pagination-previous { + overflow: hidden; +} +a.pagination-next { + overflow: hidden; +} +.button.checkbox, .button.checkbox .checkmark { + transition: linear .2s; +} diff --git a/bst@asphyxia/webui/js/webui_util.js b/bst@asphyxia/webui/js/webui_util.js new file mode 100644 index 0000000..33ef6f5 --- /dev/null +++ b/bst@asphyxia/webui/js/webui_util.js @@ -0,0 +1,618 @@ +function initializePaginatedContent() { + let containers = document.querySelectorAll(".paginated-container") + + for (let container of containers) { + let pageSizeInput = container.querySelector("input.page-size") + let paginations = container.querySelectorAll(".pagination") + let contents = container.querySelectorAll(".paginated-content") + let group = container.getAttribute("pagination-group") + let flags = { isFirst: true } + let refreshEllipsis = (param) => { + if (flags.isFirst) return + let maxWidth = container.offsetWidth / 2 + for (let pagination of paginations) { + let buttons = pagination.querySelector("ul.pagination-list") + if (buttons.childElementCount == 0) return + let show = (index) => buttons.querySelector("li[tab-index=\"" + index + "\"]").style.display = "block" + let hide = (index) => buttons.querySelector("li[tab-index=\"" + index + "\"]").style.display = "none" + let previousButton = pagination.querySelector("a.pagination-previous") + let nextButton = pagination.querySelector("a.pagination-next") + let leftEllipsis = buttons.querySelector("li.ellipsis-left") + let rightEllipsis = buttons.querySelector("li.ellipsis-right") + let width = buttons.firstChild.offsetWidth.toString() + leftEllipsis.style.width = width + "px" + rightEllipsis.style.width = width + "px" + let count = buttons.childElementCount - 2 + let maxButtonCount = Math.max((buttons.firstChild.offsetWidth == 0) ? 5 : Math.trunc(maxWidth / buttons.firstChild.offsetWidth), 5) + let current = (param instanceof HTMLElement) ? param : buttons.querySelector("li.is-active") + let index = parseInt((current == null) ? 0 : current.getAttribute("tab-index")) + if (index == 0) previousButton.setAttribute("disabled", "") + else previousButton.removeAttribute("disabled") + if (index == (count - 1)) nextButton.setAttribute("disabled", "") + else nextButton.removeAttribute("disabled") + if (count <= maxButtonCount) { + for (let i = 0; i < count; i++) buttons.querySelector("li[tab-index=\"" + i + "\"]").style.display = "block" + leftEllipsis.style.display = "none" + rightEllipsis.style.display = "none" + } else { + maxButtonCount = Math.trunc((maxButtonCount - 1) / 2) * 2 + 1 + let maxSurroundingButtonCount = (maxButtonCount - 5) / 2 + let maxNoEllipsisIndex = maxButtonCount - 2 - maxSurroundingButtonCount - 1 + + if (index <= maxNoEllipsisIndex) { + for (let i = 0; i <= (maxNoEllipsisIndex + maxSurroundingButtonCount); i++) show(i) + for (let i = (maxNoEllipsisIndex + maxSurroundingButtonCount) + 1; i < count - 1; i++) hide(i) + show(count - 1) + leftEllipsis.style.display = "none" + rightEllipsis.style.display = "block" + } else if (index >= (count - maxNoEllipsisIndex - 1)) { + for (let i = 1; i < (count - maxNoEllipsisIndex - maxSurroundingButtonCount - 1); i++) hide(i) + for (let i = (count - maxNoEllipsisIndex - maxSurroundingButtonCount - 1); i < count; i++) show(i) + show(0) + leftEllipsis.style.display = "block" + rightEllipsis.style.display = "none" + } else { + for (let i = 1; i < (index - maxSurroundingButtonCount); i++) hide(i) + for (let i = (index - maxSurroundingButtonCount); i <= (index + maxSurroundingButtonCount); i++) show(i) + for (let i = (index + maxSurroundingButtonCount) + 1; i < count - 1; i++) hide(i) + show(0) + show(count - 1) + leftEllipsis.style.display = "block" + rightEllipsis.style.display = "block" + } + } + } + } + let refresh = () => { + if ((pageSizeInput == null) || (parseInt(pageSizeInput.value) <= 0)) { + for (let pagination of paginations) pagination.style.display = "none" + return + } + let pageSize = parseInt(pageSizeInput.value) + let pageCount = Math.ceil(contents.length / pageSize) + if (!flags.isFirst && (flags.pageSize == pageSize) && (flags.pageCount == pageCount)) return + for (let pagination of paginations) { + let buttons = pagination.querySelector("ul.pagination-list") + buttons.innerHTML = "" + buttons.id = "tabs" + } + for (let i = 0; i < pageCount; i++) { + for (let j = i * pageSize; j < (i + 1) * pageSize; j++) { + if (contents[j] == null) break + contents[j].classList.add("tab-content") + contents[j].setAttribute("tab-group", group) + contents[j].setAttribute("tab-index", i) + if ((i == 0) && (flags.isFirst || (flags.pageCount != pageCount))) contents[j].classList.add("is-active") + if (j == ((i + 1) * pageSize - 1)) for (let td of contents[j].querySelectorAll("td")) td.style.borderBottom = "0" + } + if (pageCount > 1) for (let pagination of paginations) { + let buttons = pagination.querySelector("ul.pagination-list") + let a = document.createElement("a") + a.classList.add("pagination-link") + a.innerText = i + 1 + let li = document.createElement("li") + li.appendChild(a) + if ((i == 0) && (flags.isFirst || (flags.pageCount != pageCount))) { + li.classList.add("is-active") + a.classList.add("is-current") + } + li.setAttribute("tab-group", group) + li.setAttribute("tab-index", i) + buttons.appendChild(li) + li.addEventListener("click", () => { + refreshEllipsis(li) + }) + } + } + if (pageCount > 1) for (let pagination of paginations) { + pagination.style.display = "flex" + let buttons = pagination.querySelector("ul.pagination-list") + let leftEllipsis = document.createElement("li") + leftEllipsis.style.display = "none" + leftEllipsis.classList.add("ellipsis-left", "ignore") + leftEllipsis.innerHTML = "…" + let rightEllipsis = document.createElement("li") + rightEllipsis.style.display = "none" + rightEllipsis.classList.add("ellipsis-right", "ignore") + rightEllipsis.innerHTML = "…" + buttons.firstChild.after(leftEllipsis) + buttons.lastChild.before(rightEllipsis) + + let previousButton = pagination.querySelector("a.pagination-previous") + let nextButton = pagination.querySelector("a.pagination-next") + previousButton.addEventListener("click", () => { + let current = buttons.querySelector("li.is-active") + let index = parseInt(current.getAttribute("tab-index")) + if (index <= 0) return + let prev = buttons.querySelector("li[tab-index=\"" + (index - 1) + "\"]") + prev.dispatchEvent(new Event("click")) + }) + nextButton.addEventListener("click", () => { + let current = buttons.querySelector("li.is-active") + let index = parseInt(current.getAttribute("tab-index")) + if (index >= (buttons.childElementCount - 3)) return // includes left & right ellipsis + let next = buttons.querySelector("li[tab-index=\"" + (index + 1) + "\"]") + next.dispatchEvent(new Event("click")) + }) + } else for (let pagination of paginations) pagination.style.display = "none" + flags.pageCount = pageCount + flags.pageSize = pageSize + flags.isFirst = false + } + refresh() + pageSizeInput.addEventListener("change", refresh) + let o = new ResizeObserver(refreshEllipsis) + o.observe(container) + } +} + +function initializeTabs() { + let tabs = document.querySelectorAll("#tabs li") + let tabContents = document.querySelectorAll("#tab-content, .tab-content") + let updateActiveTab = (tabGroup, tabIndex) => { + for (let t of tabs) if (t && (t.getAttribute("tab-group") == tabGroup)) { + if (t.getAttribute("tab-index") != tabIndex) { + t.classList.remove("is-active") + for (let a of t.querySelectorAll("a")) a.classList.remove("is-current") + } else { + t.classList.add("is-active") + for (let a of t.querySelectorAll("a")) a.classList.add("is-current") + } + } + } + + let updateActiveContent = (tabGroup, tabIndex) => { + for (let item of tabContents) { + let group = item.getAttribute("tab-group") + let index = item.getAttribute("tab-index") + if (item && (group == tabGroup)) item.classList.remove("is-active") + if ((index == tabIndex) && (group == tabGroup)) item.classList.add("is-active") + } + } + for (let t of tabs) { + if (!t.classList.contains("disabled") && !t.classList.contains("ignore")) t.addEventListener("click", () => { + let group = t.getAttribute("tab-group") + let index = t.getAttribute("tab-index") + updateActiveTab(group, index) + updateActiveContent(group, index) + }) + } +} + +function initializeToggles() { + let toggles = document.querySelectorAll(".card-header .card-toggle") + let contents = document.querySelectorAll(".card-content") + + for (let t of toggles) { + let card = t.getAttribute("card") + if (card == null) continue + let cc = [] + for (let c of contents) if (c.getAttribute("card") == card) cc.push(c) + t.style.transition = "0.2s linear" + t.addEventListener("click", (e) => { + if (e.currentTarget.style.transform == "rotate(180deg)") { + e.currentTarget.style.transform = "" + for (let c of cc) c.classList.remove("is-hidden") + } else { + e.currentTarget.style.transform = "rotate(180deg)" + for (let c of cc) c.classList.add("is-hidden") + } + }) + } +} + +function initializeModals() { + let modaltriggers = $(".modal-trigger") + for (let t of modaltriggers) { + let m = t.querySelector(".modal") + let c = m.querySelectorAll("#close") + t.addEventListener("click", (e) => { m.style.display = "flex" }) + for (let v of c) v.addEventListener("click", (e) => { + m.style.display = "none" + e.stopPropagation() + }) + } +} + +function initializeFormSelects() { + let formSelects = document.querySelectorAll("#form-select") + for (let s of formSelects) { + let input = s.querySelector("input#form-select-input") + let select = s.querySelector("select#form-select-select") + let options = select.querySelectorAll("option") + for (let i = 0; i < options.length; i++) { + let o = options[i] + let value = (o.getAttribute("value") == null) ? i : o.getAttribute("value") + let enabled = (o.getAttribute("disabled") == null) ? true : false + if (value == input.value) select.selectedIndex = i + if (!enabled) o.style.display = "none" + } + select.addEventListener("change", () => { + for (let i = 0; i < options.length; i++) { + let o = options[i] + if (o.selected) { + input.value = (o.getAttribute("value") == null) ? i : o.getAttribute("value") + input.dispatchEvent(new Event("change")) + break + } + } + }) + } +} + +function initializeFormPaginations() { + let formPags = document.querySelectorAll("#form-pagination") + for (let p of formPags) { + let input = p.querySelector("input#form-pagination-input") + let options = p.querySelectorAll("ul.pagination-list li a.pagination-link") + for (let i = 0; i < options.length; i++) { + let o = options[i] + let value = (o.getAttribute("value") == null) ? i : o.getAttribute("value") + if (value == input.value) { + if (!o.classList.contains("is-current")) o.classList.add("is-current") + } else o.classList.remove("is-current") + o.addEventListener("click", () => { + for (let i = 0; i < options.length; i++) options[i].classList.remove("is-current") + if (!o.classList.contains("is-current")) o.classList.add("is-current") + input.value = (o.getAttribute("value") == null) ? i : o.getAttribute("value") + }) + } + } +} + +function initializeFormValidation() { + let forms = document.querySelectorAll("form#validatable") + for (let f of forms) { + let validatableFields = f.querySelectorAll(".field#validatable") + let validatableButtons = f.querySelectorAll("button#validatable") + + let getParams = (input) => { + return { + minLength: input.getAttribute("min-length"), + maxLength: input.getAttribute("max-length"), + recommendedLength: input.getAttribute("recommended-length"), + minPattern: input.getAttribute("min-pattern"), + recommendedPattern: input.getAttribute("recommended-pattern"), + isNumeric: (input.getAttribute("numeric") != null) ? true : false + } + } + let isValid = (value, params) => { + let t = value.trim() + if (params.minLength != null) if (t.length < parseInt(params.minLength)) return false + if (params.maxLength != null) if (t.length > parseInt(params.maxLength)) return false + if (params.minPattern != null) if (!(new RegExp(params.minPattern).test(t))) return false + if (params.isNumeric == true) if (parseInt(t).toString() != t) return false + return true + } + + let isFormValid = () => { + for (let field of validatableFields) for (let i of field.querySelectorAll("input#validatable")) if (!isValid(i.value, getParams(i))) return false + return true + } + + for (let field of validatableFields) { + let inputs = field.querySelectorAll("input#validatable") + let tips = field.querySelectorAll(".help") + for (let i of inputs) i.addEventListener("change", () => { + let params = getParams(i) + // inputs + if (isValid(i.value, params)) { + i.classList.remove("is-danger") + for (let t of tips) t.classList.remove("is-danger") + } else if (!i.classList.contains("is-danger")) { + i.classList.add("is-danger") + for (let t of tips) t.classList.add("is-danger") + } + // buttons + if (isFormValid()) { + for (let b of validatableButtons) b.removeAttribute("disabled") + } else { + for (let b of validatableButtons) if (b.getAttribute("disabled") == null) b.setAttribute("disabled", "") + } + }) + } + } +} + +function initializeFormCollections() { + let collections = document.querySelectorAll("#form-collection") + for (let c of collections) { + let maxLength = parseInt(c.getAttribute("max-length")) + let fallbackValue = JSON.parse(c.getAttribute("fallback")) + let input = c.querySelector("#form-collection-input") + let tags = c.querySelectorAll("#form-collection-tag") + let modButton = c.querySelector("#form-collection-modify") + let modTable = c.querySelector("table#multi-select") + let modInput = modTable.querySelector("input#multi-select-input") + let modTitle = modTable.querySelector("input#multi-select-title") + let deleteButtonClickEventListener = (tag) => () => { + let tvalue = JSON.parse(tag.getAttribute("value")) + let value = JSON.parse(input.value) + value.splice(value.indexOf(tvalue), 1) + if (fallbackValue != null) value.push(fallbackValue) + input.value = JSON.stringify(value) + modInput.value = input.value + modInput.dispatchEvent(new Event("change")) + tag.remove() + } + + for (let t of tags) { + let d = t.querySelector(".delete, .is-delete") + d.addEventListener("click", deleteButtonClickEventListener(t)) + } + modInput.value = input.value + modInput.setAttribute("max-length", maxLength) + modInput.setAttribute("fallback", JSON.stringify(fallbackValue)) + modInput.addEventListener("change", () => { + let fallbackValue = JSON.parse(c.getAttribute("fallback")) + let oldValue = JSON.parse(input.value) + let newValue = JSON.parse(modInput.value) + let tags = c.querySelectorAll("#form-collection-tag") + for (let o of oldValue) if (!newValue.includes(o) && (o != fallbackValue)) { + for (let t of tags) if (JSON.parse(t.getAttribute("value")) == o) t.remove() + } + for (let n = 0; n < newValue.length; n++) if (!oldValue.includes(newValue[n]) && (newValue[n] != fallbackValue)) { + let tag = document.createElement("div") + tag.classList.add("control") + tag.id = "form-collection-tag" + tag.setAttribute("value", newValue[n]) + tag.innerHTML = "" + JSON.parse(modTitle.value)[n] + "" + tag.querySelector("a.is-delete").addEventListener("click", deleteButtonClickEventListener(tag)) + modButton.before(tag) + } + input.value = modInput.value + }) + } +} + +function initializeMultiSelectTables() { + let tables = document.querySelectorAll("table#multi-select") + for (let table of tables) { + let valueInput = table.querySelector("input#multi-select-input") + let titleInput = table.querySelector("input#multi-select-title") + let trimValues = (values, fallback) => { + while (values.includes(fallback)) values.splice(values.indexOf(fallback), 1) + return values + } + let fillValues = (values, fallback) => { + let maxLength = (valueInput.getAttribute("max-length") == null) ? -1 : parseInt(valueInput.getAttribute("max-length")) + while (values.length < maxLength) values.push(fallback) + return values + } + let lines = table.querySelectorAll("tbody tr") + let refresh = () => { + let fallbackValue = JSON.parse(valueInput.getAttribute("fallback")) + let value = trimValues(JSON.parse(valueInput.value), fallbackValue) + let title = [] + for (let l of lines) { + let lvalue = JSON.parse(l.getAttribute("multi-select-value")) + if (value.includes(lvalue)) { + if (!l.classList.contains("is-selected")) l.classList.add("is-selected") + title[value.indexOf(lvalue)] = l.getAttribute("multi-select-title") + l.style.fontWeight = "bold" + } else { + l.classList.remove("is-selected") + l.style.fontWeight = "" + } + } + titleInput.value = JSON.stringify(title) + } + + for (let l of lines) { + l.onclick = () => { + let fallbackValue = JSON.parse(valueInput.getAttribute("fallback")) + let maxLength = (valueInput.getAttribute("max-length") == null) ? -1 : parseInt(valueInput.getAttribute("max-length")) + let value = trimValues(JSON.parse(valueInput.value), fallbackValue) + let lvalue = JSON.parse(l.getAttribute("multi-select-value")) + if (value.includes(lvalue)) value.splice(value.indexOf(lvalue), 1) + else if (maxLength >= 0) { + if (value.length < maxLength) value.push(lvalue) + else alert("Cannot add more items, items are up to " + maxLength + ".") + } else value.push(lvalue) + valueInput.value = JSON.stringify(fillValues(value, fallbackValue)) + refresh() + valueInput.dispatchEvent(new Event("change")) + } + refresh() + } + valueInput.addEventListener("change", refresh) + } +} + +function initializeFormNumerics() { + let numerics = document.querySelectorAll("#form-numeric") + for (let n of numerics) { + let add = n.querySelector("#form-numeric-add") + let sub = n.querySelector("#form-numeric-sub") + let inputs = n.querySelectorAll("#form-numeric-input") + add.addEventListener("click", (e) => { + for (let i of inputs) { + let maxValue = parseFloat(i.getAttribute("max-value")) + let step = parseFloat(i.getAttribute("step")) + + let digitCount = (i.getAttribute("digit-count") == null) ? -1 : parseInt(i.getAttribute("digit-count")) + let value = (parseFloat(i.value) * 10 + step * 10) / 10 + if (value * Math.sign(step) <= maxValue * Math.sign(step)) i.value = (digitCount >= 0) ? value.toFixed(digitCount) : value + } + e.stopPropagation() + }) + sub.addEventListener("click", (e) => { + for (let i of inputs) { + let minValue = parseFloat(i.getAttribute("min-value")) + let step = parseFloat(i.getAttribute("step")) + let digitCount = (i.getAttribute("digit-count") == null) ? -1 : parseInt(i.getAttribute("digit-count")) + let value = (parseFloat(i.value) * 10 - step * 10) / 10 + if (value * Math.sign(step) >= minValue * Math.sign(step)) i.value = (digitCount >= 0) ? value.toFixed(digitCount) : value + } + e.stopPropagation() + }) + for (let i of inputs) { + let digitCount = (i.getAttribute("digit-count") == null) ? -1 : parseInt(i.getAttribute("digit-count")) + let value = parseFloat(i.value) + i.value = (digitCount >= 0) ? value.toFixed(digitCount) : value + } + } +} + +function initializeUploader() { + let uploaders = document.querySelectorAll("div#uploader") + for (let uploader of uploaders) { + let input = uploader.querySelector("input#uploader-input") + let text = uploader.querySelector("input#uploader-text") + let placeholder = uploader.querySelector("#uploader-placeholder") + let remove = uploader.querySelector("#uploader-delete") + let reader = new FileReader() + input.addEventListener("change", () => { + if (input.files.length > 0) { + remove.style.display = "block" + placeholder.innerText = input.files[0].name + reader.readAsText(input.files[0]) + reader.onload = () => text.value = reader.result + } else { + placeholder.innerText = "" + remove.style.display = "none" + text.value = null + } + }) + remove.addEventListener("click", (e) => { + e.stopPropagation() + input.value = null + input.dispatchEvent(new Event("change")) + }) + + remove.style.display = "none" + } +} + +function checkImg() { + let imgs = document.querySelectorAll("#exist-or-not") + for (let img of imgs) { + let general = img.querySelector("img#general") + let specified = img.querySelector("img#specified") + + if (specified.width == 0) specified.style.display = "none" + else general.style.display = "none" + } +} + +function initializeMarqueeLabels() { + let marqueeContainers = document.querySelectorAll(".marquee-label-container") + for (let c of marqueeContainers) { + let marquees = c.querySelectorAll(".marquee-label") + for (let marquee of marquees) { + if (marquee.closest(".marquee-label-container") != c) continue + let refresh = () => { + let lpad = parseInt(window.getComputedStyle(c, null).getPropertyValue("padding-left")) + if (lpad == NaN) lpad = 0 + let rpad = parseInt(window.getComputedStyle(c, null).getPropertyValue("padding-right")) + if (rpad == NaN) rpad = 20 + let hpad = lpad + rpad + let speed = marquee.getAttribute("speed") + if (speed == null) speed = 1 + let stopingTime = 0.5 + let duration = (20 * (marquee.offsetWidth - c.offsetWidth + hpad)) / speed + 2 * stopingTime + if ((marquee.offsetWidth > 0) && (marquee.offsetWidth > c.offsetWidth - hpad)) { + marquee.animate([ + { transform: "translateX(0)", offset: 0 }, + { transform: "translateX(0)", easing: "cubic-bezier(0.67, 0, 0.33, 1)", offset: stopingTime / duration }, + { transform: "translateX(" + (c.offsetWidth - marquee.offsetWidth - hpad) + "px)", easing: "cubic-bezier(0.67, 0, 0.33, 1)", offset: 1 - stopingTime / duration }, + { transform: "translateX(" + (c.offsetWidth - marquee.offsetWidth - hpad) + "px)", offset: 1 } + ], { duration: (20 * (marquee.offsetWidth - c.offsetWidth) + 1000) / speed, direction: "alternate-reverse", iterations: Infinity }) + } else marquee.style.animation = "none" + } + let o = new ResizeObserver(refresh) + o.observe(c) + } + } +} + +function initializeNotificatioAnimation() { + let notifications = document.querySelectorAll(".notification.temporary") + for (let n of notifications) { + let remove = n.querySelector(".delete") + let startSubmitter = n.querySelector("form.start") + let startPath = startSubmitter.getAttribute("action") + let startRequest = new XMLHttpRequest() + startRequest.open("POST", startPath, true) + startRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded") + + let endSubmitter = n.querySelector("form.end") + let endPath = startSubmitter.getAttribute("action") + let endRequest = new XMLHttpRequest() + endRequest.open("POST", endPath, true) + endRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded") + + if (startSubmitter != null) startRequest.send() + let end = () => { + n.style.display = "none" + if (endSubmitter != null) endRequest.send() + } + + n.style.animationPlayState = "running" + remove.addEventListener("click", end) + n.addEventListener("animationend", end) + n.addEventListener("webkitAnimationEnd", end) + } +} + +function initializeCheckBoxes() { + let checks = document.querySelectorAll(".checkbox") + for (let c of checks) { + let input = c.querySelector("input[type=checkbox]") + let mark = c.querySelector(".checkmark") + let refresh = (value) => { + value = input.getAttribute("checked") + if (value == null) { + input.removeAttribute("checked") + mark.style.opacity = 0 + if (!c.classList.contains("is-light")) c.classList.add("is-light") + } else { + input.setAttribute("checked", "checked") + mark.style.opacity = 100 + c.classList.remove("is-light") + } + } + c.addEventListener("click", () => { + let value = input.getAttribute("checked") + if (value == null) input.setAttribute("checked", "checked") + else input.removeAttribute("checked") + refresh() + }) + refresh() + } +} + +function removeLoadingModal() { + let loading = document.querySelector(".loading") + setTimeout(() => (loading == null) ? null : loading.remove(), 505) + try { + let a = loading.animate([ + { offset: 0, opacity: 1 }, + { offset: 0.25, opacity: 0 }, + { offset: 1, opacity: 0 } + ], { duration: 2000 }) + a.onfinish = loading.remove + a.play() + } catch { } +} + +$(document).ready(() => { + initializeNotificatioAnimation() + initializePaginatedContent() + initializeTabs() + initializeToggles() + initializeModals() + initializeFormSelects() + initializeFormNumerics() + initializeFormPaginations() + initializeFormValidation() + initializeFormCollections() + initializeMultiSelectTables() + initializeUploader() + checkImg() + initializeMarqueeLabels() + initializeCheckBoxes() + + removeLoadingModal() +}) + diff --git a/bst@asphyxia/webui/profile_detail.pug b/bst@asphyxia/webui/profile_detail.pug new file mode 100644 index 0000000..a87f3ff --- /dev/null +++ b/bst@asphyxia/webui/profile_detail.pug @@ -0,0 +1,750 @@ +//DATA// + bst2Account: DB.FindOne(refid, { collection: "bst.bst2.player.account" }) + bst2Base: DB.FindOne(refid, { collection: "bst.bst2.player.base" }) + bst2Customization: DB.FindOne(refid, { collection: "bst.bst2.player.customization" }) + bst2Course: DB.Find({ collection: "bst.bst2.playData.course#userId" }) + bst2MusicRecord: DB.Find({ collection: "bst.bst2.playData.musicRecord#userId" }) + bst2CourseLog: DB.Find({ collection: "bst.bst2.playData.courseLog#userId" }) + bst2StageLog: DB.Find({ collection: "bst.bst2.playData.stageLog#userId" }) + + webuiMessage: DB.FindOne({ collection: "utility.webuiMessage" }) + +//- Definitions +- + let defaultVersion = 2 + + let bstMusicsInfo = [{ musicId: 0, title: "SAVIOR OF SONG", version: 1, category: "ANIME", bpm: { min: 192, max: 192 }, chartsInfo: { light: "０２", medium: "０８", beast: "０９", nightmare: "１０" }, artist: "ナノ feat. MY FIRST STORY" }, { musicId: 1, title: "マネマネサイコトロピック", version: 1, category: "EXITTUNES", bpm: { min: 135, max: 210 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁺" }, artist: "かいりきベア" }, { musicId: 2, title: "ミスターデジャブ", version: 1, category: "EXITTUNES", bpm: { min: 230, max: 230 }, chartsInfo: { light: "０１", medium: "０６", beast: "１０⁻" }, artist: "164 feat.MAYU" }, { musicId: 3, title: "セツナトリップ", version: 1, category: "EXITTUNES", bpm: { min: 145, max: 145 }, chartsInfo: { light: "０１", medium: "０６", beast: "０９⁻", nightmare: "１０" }, artist: "Last Note. feat. GUMI" }, { musicId: 4, title: "ラクガキスト", version: 1, category: "EXITTUNES", bpm: { min: 199, max: 199 }, chartsInfo: { light: "０５", medium: "０９⁻", beast: "０９⁺", nightmare: "10⁺" }, artist: "cosMo＠暴走P feat.GUMI" }, { musicId: 5, title: "放課後ストライド", version: 1, category: "EXITTUNES", bpm: { min: 225, max: 225 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁻", nightmare: "１０" }, artist: "Last Note." }, { musicId: 6, title: "リズの内心革命", version: 1, category: "EXITTUNES", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "じっぷす" }, { musicId: 7, title: "ロストワンの号哭", version: 1, category: "EXITTUNES", bpm: { min: 162, max: 162 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０", nightmare: "１０" }, artist: "Neru" }, { musicId: 8, title: "HΨ=世界創造=EΨ", version: 1, category: "EXITTUNES", bpm: { min: 208, max: 208 }, chartsInfo: { light: "０３", medium: "０８", beast: "１０" }, artist: "黒猫アンティーク feat.IA,GUMI" }, { musicId: 9, title: "Nyan Cat", version: 1, category: "EXITTUNES", bpm: { min: 142, max: 142 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "daniwellP feat. 桃音モモ" }, { musicId: 10, title: "天ノ弱", version: 1, category: "EXITTUNES", bpm: { min: 200, max: 205 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "164" }, { musicId: 11, title: "恋愛勇者", version: 1, category: "EXITTUNES", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "Last Note." }, { musicId: 12, title: "ねこみみスイッチ", version: 1, category: "EXITTUNES", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８", nightmare: "０９⁻" }, artist: "daniwellP" }, { musicId: 13, title: "にゃにゃにゃんにゃんにゃーのこねこ", version: 1, category: "EXITTUNES", bpm: { min: 184, max: 184 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁺" }, artist: "daniwellP" }, { musicId: 14, title: "過食性:アイドル症候群", version: 1, category: "EXITTUNES", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "スズム" }, { musicId: 15, title: "チルノのパーフェクトさんすう教室", version: 1, category: "TOHO", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁻", nightmare: "０９⁺" }, artist: "ARM＋夕野ヨシミ feat. miko" }, { musicId: 16, title: "待チ人ハ来ズ。", version: 1, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０３", medium: "０６", beast: "０８" }, artist: "豚乙女" }, { musicId: 17, title: "月に叢雲華に風", version: 1, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁻", nightmare: "10-" }, artist: "幽閉サテライト(Arranged:Iceon) feat. senya" }, { musicId: 18, title: "物凄い勢いでけーねが物凄いうた", version: 1, category: "TOHO", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "Halozy feat. ななひら" }, { musicId: 19, title: "INFINITE WORLD", version: 1, category: "TOHO", bpm: { min: 167, max: 167 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９", nightmare: "１０" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 20, title: "ウサテイ", version: 1, category: "TOHO", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "あまね＋ビートまりお（COOL&CREATE）" }, { musicId: 21, title: "魔理沙は大変なものを盗んでいきました", version: 1, category: "TOHO", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺", nightmare: "１０" }, artist: "ARM＋夕野ヨシミ feat. 藤咲かりん" }, { musicId: 22, title: "色は匂へど 散りぬるを", version: 1, category: "TOHO", bpm: { min: 138, max: 138 }, chartsInfo: { light: "０３", medium: "０６", beast: "０８" }, artist: "幽閉サテライト(Arranged:Iceon) feat. senya" }, { musicId: 23, title: "お嫁にしなさいっ！", version: 1, category: "TOHO", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "ARM＋夕野ヨシミ" }, { musicId: 24, title: "しゅわスパ大作戦☆", version: 1, category: "TOHO", bpm: { min: 140, max: 140 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 25, title: "げきオコスティックファイナリアリティぷんぷんマスタースパーク", version: 1, category: "TOHO", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "ARM＋ビートまりお（COOL&CREATE）" }, { musicId: 26, title: "ケロ⑨destiny", version: 1, category: "TOHO", bpm: { min: 172, max: 172 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺" }, artist: "Silver Forest feat. めらみぽっぷ" }, { musicId: 27, title: "Miracle Halloween", version: 1, category: "KDE", bpm: { min: 140, max: 140 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "Sana" }, { musicId: 28, title: "ミライノトビラ", version: 1, category: "KDE", bpm: { min: 163, max: 163 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "Sana" }, { musicId: 29, title: "ちくわパフェだよ☆ＣＫＰ", version: 1, category: "KDE", bpm: { min: 205, max: 205 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺", nightmare: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 30, title: "Colorful Days ～NEWラブプラス メインテーマ～", version: 1, category: "KDE", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "高嶺愛花＆小早川凛子＆姉ヶ崎寧々" }, { musicId: 31, title: "Rainbow Magic", version: 1, category: "KDE", bpm: { min: 124, max: 150 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "マジックアカデミー管弦楽部×劇団レコード" }, { musicId: 32, title: "チュートリアル", version: 2, category: "KDE", bpm: { min: 100, max: 100 }, chartsInfo: { light: "０１" }, artist: "-" }, { musicId: 33, title: "回レ！雪月花", version: 1, category: "ANIME", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "歌組雪月花" }, { musicId: 34, title: "Anicca", version: 1, category: "ANIME", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "原田ひとみ" }, { musicId: 35, title: "This game", version: 1, category: "ANIME", bpm: { min: 147, max: 147 }, chartsInfo: { light: "０２", medium: "０４", beast: "０９⁻", nightmare: "０９⁺" }, artist: "鈴木このみ" }, { musicId: 36, title: "オラシオン", version: 1, category: "ANIME", bpm: { min: 166, max: 166 }, chartsInfo: { light: "０１", medium: "０４", beast: "０８", nightmare: "０９⁻" }, artist: "白（CV:茅野愛衣）" }, { musicId: 37, title: "共鳴のTrue Force", version: 1, category: "ANIME", bpm: { min: 187.5, max: 187.5 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁺" }, artist: "原田ひとみ" }, { musicId: 38, title: "精霊剣舞祭", version: 1, category: "ANIME", bpm: { min: 187, max: 187 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "にーそっくすす" }, { musicId: 39, title: "祝祭のエレメンタリア", version: 1, category: "ANIME", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "にーそっくすす" }, { musicId: 40, title: "幻想系世界修復少女", version: 1, category: "EXITTUNES", bpm: { min: 193, max: 193 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "Last Note." }, { musicId: 41, title: "バンブーソード・ガール", version: 1, category: "EXITTUNES", bpm: { min: 208, max: 208 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９" }, artist: "cosMo＠暴走P" }, { musicId: 42, title: "Idola", version: 1, category: "KDE", bpm: { min: 201, max: 201 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "iconoclasm feat.GUMI" }, { musicId: 43, title: "サリシノハラ", version: 1, category: "EXITTUNES", bpm: { min: 135, max: 135 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８", nightmare: "０９⁻" }, artist: "みきとP" }, { musicId: 44, title: "脱出ゲヱム", version: 1, category: "EXITTUNES", bpm: { min: 134, max: 134 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０⁻" }, artist: "ゆちゃP" }, { musicId: 45, title: "ケッペキショウ", version: 1, category: "EXITTUNES", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０⁻" }, artist: "すこっぷ" }, { musicId: 46, title: "僕は空気が嫁ない", version: 1, category: "EXITTUNES", bpm: { min: 192, max: 192 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "cosMo＠暴走P" }, { musicId: 47, title: "sweet little sister", version: 1, category: "TOHO", bpm: { min: 168, max: 168 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "Silver Forest feat. さゆり" }, { musicId: 48, title: "泡沫、哀のまほろば", version: 1, category: "TOHO", bpm: { min: 155, max: 155 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "幽閉サテライト(Arranged:Iceon,HiZuMi) feat. senya" }, { musicId: 49, title: "最終鬼畜妹フランドール・S", version: 1, category: "TOHO", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０⁻", nightmare: "１０" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 50, title: "Help me, ERINNNNNN!!", version: 1, category: "TOHO", bpm: { min: 183, max: 183 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻", nightmare: "10-" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 51, title: "ナイト・オブ・ナイツ", version: 1, category: "TOHO", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 52, title: "†渚の小悪魔ラヴリィ～レイディオ† ", version: 1, category: "KDE", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０８", beast: "０９⁺" }, artist: "夏色ビキニのPrim" }, { musicId: 53, title: "恋する☆宇宙戦争っ！！", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "ネ申" }, artist: "Prim" }, { musicId: 54, title: "狂イ咲ケ焔ノ華", version: 1, category: "KDE", bpm: { min: 206, max: 206 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０⁻" }, artist: "覚醒ノPrim" }, { musicId: 55, title: "めうめうぺったんたん！！", version: 1, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 56, title: "カタルシスの月", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "日向美ビタースイーツ♪" }, { musicId: 57, title: "凛として咲く花の如く　～ひなビタ♪edition～", version: 1, category: "KDE", bpm: { min: 163, max: 163 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻", nightmare: "０９⁺" }, artist: "日向美ビタースイーツ♪" }, { musicId: 58, title: "滅亡天使 † にこきゅっぴん", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 59, title: "Bad Apple!! feat. nomico", version: 1, category: "TOHO", bpm: { min: 138, max: 138 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺", nightmare: "10-" }, artist: "Alstroemeria Records" }, { musicId: 60, title: "ビビットストリーム", version: 1, category: "KDE", bpm: { min: 184, max: 184 }, chartsInfo: { light: "０３", medium: "０８", beast: "０９⁻", nightmare: "10-" }, artist: "DJ TOTTO" }, { musicId: 61, title: "groovin'", version: 1, category: "KDE", bpm: { min: 140, max: 140 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "Sota Fujimori" }, { musicId: 62, title: "センチメンタルラブ", version: 1, category: "ANIME", bpm: { min: 138, max: 138 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "みみめめMIMI" }, { musicId: 63, title: "sister’s noise", version: 1, category: "ANIME", bpm: { min: 144, max: 144 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻", nightmare: "０９⁺" }, artist: "fripSide" }, { musicId: 64, title: "Daydream café", version: 1, category: "ANIME", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０５", medium: "０８", beast: "０９⁺", nightmare: "１０" }, artist: "Petit Rabbit’s" }, { musicId: 65, title: "閃光の行方", version: 1, category: "ANIME", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０３", medium: "１０", beast: "１０" }, artist: "Falcom Sound Team jdk" }, { musicId: 66, title: "I'll remember you", version: 1, category: "ANIME", bpm: { min: 148, max: 148 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "Falcom Sound Team jdk" }, { musicId: 67, title: "乙女繚乱 舞い咲き誇れ", version: 1, category: "KDE", bpm: { min: 210, max: 210 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 68, title: "Harmonia", version: 1, category: "KDE", bpm: { min: 177, max: 177 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "ATSUMI UEDA" }, { musicId: 69, title: "青春セッション PARADISE", version: 1, category: "OTHER", bpm: { min: 150, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０", nightmare: "１０" }, artist: "A応P" }, { musicId: 70, title: "きょうもハレバレ", version: 1, category: "EXITTUNES", bpm: { min: 134, max: 134 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "ふわりP feat. GUMI's" }, { musicId: 71, title: "ノイジーラバーソウル", version: 1, category: "EXITTUNES", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "Last Note." }, { musicId: 72, title: "0", version: 1, category: "EXITTUNES", bpm: { min: 168, max: 168 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "cosMo＠暴走P" }, { musicId: 73, title: "いーあるふぁんくらぶ", version: 1, category: "EXITTUNES", bpm: { min: 145, max: 145 }, chartsInfo: { light: "０２", medium: "０４", beast: "０９⁻" }, artist: "みきとP" }, { musicId: 74, title: "幸せになれる隠しコマンドがあるらしい", version: 1, category: "EXITTUNES", bpm: { min: 142, max: 142 }, chartsInfo: { light: "０１", medium: "０６", beast: "０９⁺", nightmare: "０９⁺" }, artist: "うたたP feat. 結月ゆかり" }, { musicId: 75, title: "Phantasm Brigade", version: 1, category: "TOHO", bpm: { min: 168, max: 168 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "Silver Forest" }, { musicId: 76, title: "突撃!ガラスのニーソ姫!", version: 1, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０３", medium: "０８", beast: "１０⁻" }, artist: "山本椛 (monotone)" }, { musicId: 77, title: "キャトられ♥恋はモ～モク", version: 1, category: "KDE", bpm: { min: 196, max: 196 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "ギュ～っとしたい♥Prim" }, { musicId: 78, title: "即席！脳直★ミュージックシステム", version: 1, category: "KDE", bpm: { min: 197, max: 197 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "MOSAIC.WAV" }, { musicId: 79, title: "Synchrogazer", version: 1, category: "ANIME", bpm: { min: 159, max: 159 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻", nightmare: "１０" }, artist: "水樹奈々" }, { musicId: 80, title: "家出少年と迷子少女", version: 1, category: "EXITTUNES", bpm: { min: 165, max: 165 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁻" }, artist: "cosMo＠暴走P feat. GUMI" }, { musicId: 81, title: "白い雪のプリンセスは", version: 1, category: "EXITTUNES", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻", nightmare: "０９⁺" }, artist: "のぼる↑" }, { musicId: 82, title: "命のユースティティア", version: 1, category: "EXITTUNES", bpm: { min: 156, max: 156 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "Neru" }, { musicId: 83, title: "再教育", version: 1, category: "EXITTUNES", bpm: { min: 163, max: 163 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁻" }, artist: "Neru" }, { musicId: 84, title: "ドロボウナイトトリック", version: 1, category: "EXITTUNES", bpm: { min: 218, max: 218 }, chartsInfo: { light: "０５", medium: "０９⁻", beast: "０９⁺" }, artist: "ゆちゃP" }, { musicId: 85, title: "茅蜩モラトリアム", version: 1, category: "EXITTUNES", bpm: { min: 189, max: 189 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "TOTAL OBJECTION feat.GUMI" }, { musicId: 86, title: "十面相", version: 1, category: "EXITTUNES", bpm: { min: 173, max: 173 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "YM feat. GUMI" }, { musicId: 87, title: "ハウトゥー世界征服", version: 1, category: "EXITTUNES", bpm: { min: 151, max: 151 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "Neru" }, { musicId: 88, title: "Just Be Friends", version: 1, category: "EXITTUNES", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "Dixie Flatline" }, { musicId: 89, title: "ハッタリだけで生きてる", version: 1, category: "EXITTUNES", bpm: { min: 145, max: 145 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁻" }, artist: "recog feat. デッドボールP" }, { musicId: 90, title: "ってゐ！ ～えいえんてゐVer～", version: 1, category: "TOHO", bpm: { min: 314, max: 340 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "石鹸屋" }, { musicId: 91, title: "東方妖々夢 ～the maximum moving about～", version: 1, category: "TOHO", bpm: { min: 197, max: 205 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "石鹸屋" }, { musicId: 92, title: "最速最高シャッターガール", version: 1, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０３", medium: "０８", beast: "０９⁺" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 93, title: "マスパでシュッ☆メイドウィッチまりさちゃん", version: 1, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "ARM feat.桃井はるこ" }, { musicId: 94, title: "進捗どうですか？", version: 1, category: "TOHO", bpm: { min: 199, max: 199 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "sumijun feat.ななひら" }, { musicId: 95, title: "トラウマ催眠少女さとり！", version: 1, category: "TOHO", bpm: { min: 210, max: 210 }, chartsInfo: { light: "０３", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "DJ SHARPNEL feat.一ノ瀬月琉" }, { musicId: 96, title: "きゅうりバーにダイブ", version: 1, category: "TOHO", bpm: { min: 176, max: 176 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺" }, artist: "ゆずひこ feat.めらみぽっぷ" }, { musicId: 97, title: "ジャスティス・オブ・ザ・界隈　～ALL IS FAIR IN LOVE AND ALIMARI～", version: 1, category: "TOHO", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "void feat.山本椛" }, { musicId: 98, title: "EBONY & IVORY", version: 1, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０２", medium: "０８", beast: "１０⁻", nightmare: "10⁺" }, artist: "OSTER project" }, { musicId: 99, title: "ツーマンライブ", version: 1, category: "KDE", bpm: { min: 174, max: 174 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺", nightmare: "10-" }, artist: "東雲夏陽 meets 日向美ビタースイーツ♪" }, { musicId: 100, title: "キモチコネクト", version: 1, category: "KDE", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻", nightmare: "０９⁺" }, artist: "東雲心菜 meets 日向美ビタースイーツ♪" }, { musicId: 101, title: "パ→ピ→プ→Yeah!", version: 1, category: "KDE", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻", nightmare: "１０" }, artist: "ヒゲドライバー join. shully & Nimo" }, { musicId: 102, title: "惑星☆ロリポップ", version: 1, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９", nightmare: "１０" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 103, title: "爆なな☆てすとロイヤー", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０８", beast: "１０⁻", nightmare: "１０" }, artist: "ARM feat.ななひら" }, { musicId: 104, title: "Stay Gold", version: 1, category: "OTHER", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０２", medium: "０８", beast: "１０", nightmare: "１０" }, artist: "A応P" }, { musicId: 105, title: "メイビ～初恋！？ビスケット☆大作戦", version: 1, category: "KDE", bpm: { min: 182, max: 182 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９", nightmare: "10-" }, artist: "DJ TOTTO×mitsu feat.BisCo(CV:洲崎綾)" }, { musicId: 106, title: "それは花火のような恋", version: 1, category: "KDE", bpm: { min: 182, max: 182 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０", nightmare: "１０" }, artist: "夏色バーニングラブ☆Prim" }, { musicId: 107, title: "NEON WORLD", version: 1, category: "TOHO", bpm: { min: 154, max: 164 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 108, title: "Scarlet Moon", version: 1, category: "TOHO", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０２", medium: "０４", beast: "０９⁻" }, artist: "REDALiCE feat. Ayumi Nomiya" }, { musicId: 109, title: "Russian Caravan Rhapsody", version: 1, category: "TOHO", bpm: { min: 158, max: 158 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "Power Of Nature" }, { musicId: 110, title: "ほおずき程度には赤い頭髪", version: 1, category: "TOHO", bpm: { min: 174, max: 174 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "Akhuta" }, { musicId: 111, title: "取り残された美術(Arranged:HiZuMi)", version: 1, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁺" }, artist: "幽閉サテライト feat. senya" }, { musicId: 112, title: "Struggle", version: 1, category: "TOHO", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "Masayoshi Minoshima(ALR)" }, { musicId: 113, title: "ホメ猫☆センセーション", version: 1, category: "TOHO", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺" }, artist: "P*Light feat. mow*2" }, { musicId: 114, title: "妖隠し -あやかしかくし-", version: 1, category: "TOHO", bpm: { min: 85, max: 85 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "DJ TOTTO feat.3L" }, { musicId: 115, title: "BEAT-NEW-WORLD", version: 1, category: "TOHO", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 116, title: "プレインエイジア -PHQ remix-", version: 1, category: "TOHO", bpm: { min: 182, max: 182 }, chartsInfo: { light: "０２", medium: "０７", beast: "１０⁻" }, artist: "PHQUASE" }, { musicId: 117, title: "竹取飛翔 ～ Lunatic Princess (Ryu☆Remix)", version: 1, category: "TOHO", bpm: { min: 171, max: 171 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９" }, artist: "Ryu☆" }, { musicId: 118, title: "千年ノ理", version: 1, category: "TOHO", bpm: { min: 153, max: 153 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺" }, artist: "猫叉Master" }, { musicId: 119, title: "Flyers", version: 1, category: "ANIME", bpm: { min: 139, max: 139 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "BRADIO" }, { musicId: 120, title: "放課後革命", version: 1, category: "ANIME", bpm: { min: 205, max: 205 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "放課後楽園部《一宮エルナ（CV:木村珠莉）・御神楽星鎖（CV：大西沙織）・藤白おとね（CV:小澤亜李）》" }, { musicId: 121, title: "楽園ファンファーレ", version: 1, category: "ANIME", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "放課後楽園部《一宮エルナ（CV:木村珠莉）・御神楽星鎖（CV：大西沙織）・藤白おとね（CV:小澤亜李）》" }, { musicId: 122, title: "FLOWER", version: 1, category: "KDE", bpm: { min: 173, max: 173 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０⁺" }, artist: "DJ YOSHITAKA" }, { musicId: 123, title: "海神", version: 1, category: "KDE", bpm: { min: 159, max: 159 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０⁺" }, artist: "兎々" }, { musicId: 124, title: "蛇神", version: 1, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "Zektbach" }, { musicId: 125, title: "Ha･lle･lu･jah", version: 1, category: "KDE", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 126, title: "Element of SPADA", version: 1, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０３", medium: "０６", beast: "１０" }, artist: "猫叉Master feat.霜月はるか" }, { musicId: 127, title: "ジュピターガンズノベル", version: 1, category: "KDE", bpm: { min: 156, max: 156 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "工藤吉三（ベイシスケイプ）" }, { musicId: 128, title: "ヤマトなでなで♡かぐや姫", version: 1, category: "KDE", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０３", medium: "０８", beast: "０９⁺" }, artist: "ロマンチック♡Prim姫" }, { musicId: 129, title: "チョコレートスマイル", version: 1, category: "KDE", bpm: { min: 196, max: 196 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻", nightmare: "10-" }, artist: "日向美ビタースイーツ♪ & ここなつ" }, { musicId: 130, title: "さよならトリップ ～夏陽 EDM edition～", version: 1, category: "KDE", bpm: { min: 135, max: 135 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻", nightmare: "10-" }, artist: "東雲夏陽(from ここなつ)" }, { musicId: 131, title: "魔法のたまご ～心菜 ELECTRO POP edition～", version: 1, category: "KDE", bpm: { min: 142, max: 142 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺", nightmare: "１０" }, artist: "東雲心菜(from ここなつ)" }, { musicId: 132, title: "怪盗BisCoの予告状！！", version: 1, category: "KDE", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻", nightmare: "１０" }, artist: "Qrispy Joybox" }, { musicId: 133, title: "リトライ☆ランデヴー", version: 1, category: "ANIME", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "にゃ～たん（CV:村川梨衣）" }, { musicId: 134, title: "そるらる★とんちんかん", version: 1, category: "OTHER", bpm: { min: 195, max: 195 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "にゃ～たん（CV:村川梨衣）" }, { musicId: 135, title: "blue moment", version: 1, category: "ANIME", bpm: { min: 149, max: 149 }, chartsInfo: { light: "０１", medium: "０６", beast: "０９⁻" }, artist: "ソルラルBOB" }, { musicId: 136, title: "ソルラルくれにゃ！", version: 1, category: "OTHER", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "エトリオール（CV:村川梨衣、松井恵理子、花守ゆみり）" }, { musicId: 137, title: "In The Breeze", version: 1, category: "KDE", bpm: { min: 123, max: 142 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "96 & Sota ft. Mayumi Morinaga" }, { musicId: 138, title: "びいすと！", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９", nightmare: "１０" }, artist: "ビートまりおとARM" }, { musicId: 139, title: "放課後ストライド", version: 1, category: "OTHER", bpm: { min: 231, max: 231 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "一宮エルナ（CV.木村珠莉）" }, { musicId: 140, title: "革新的ヒロイズム", version: 1, category: "OTHER", bpm: { min: 153, max: 153 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "二宮シグレ（CV.島﨑信長）" }, { musicId: 141, title: "有頂天ビバーチェ", version: 1, category: "OTHER", bpm: { min: 133, max: 133 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "八坂ひみ（CV.諏訪彩花）" }, { musicId: 142, title: "十六夜シーイング", version: 1, category: "OTHER", bpm: { min: 174, max: 174 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "射水アスヒ（CV.加隈亜衣）" }, { musicId: 143, title: "我楽多イノセンス", version: 1, category: "OTHER", bpm: { min: 230, max: 230 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "九頭竜京摩（CV.細谷佳正）" }, { musicId: 144, title: "無気力クーデター", version: 1, category: "OTHER", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "赤間遊兎（CV.花江夏樹）" }, { musicId: 145, title: "花吹雪リフレクト", version: 1, category: "OTHER", bpm: { min: 118, max: 118 }, chartsInfo: { light: "０２", medium: "０５", beast: "０８" }, artist: "湊川貞松（CV.古川慎）" }, { musicId: 146, title: "絵空事スパイラル", version: 1, category: "OTHER", bpm: { min: 197, max: 197 }, chartsInfo: { light: "０５", medium: "０８", beast: "０９⁺" }, artist: "御神楽星鎖（CV.大西沙織）" }, { musicId: 147, title: "赤裸々キャンディ", version: 1, category: "OTHER", bpm: { min: 193, max: 193 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "藤白おとね（CV.小澤亜李）" }, { musicId: 148, title: "不条理ルーレット", version: 1, category: "OTHER", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁺" }, artist: "ビミィ（CV.松岡禎丞）" }, { musicId: 149, title: "激メシ!!わがにゃの晩ごはん", version: 1, category: "OTHER", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁻" }, artist: "にゃ～たん（CV：村川梨衣）、モ～たん（CV：松井恵理子）、ピヨたん（CV：佐々木未来）" }, { musicId: 150, title: "これがにゃあの生きる道", version: 1, category: "OTHER", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "にゃ～たん（CV：村川梨衣）" }, { musicId: 151, title: "ラヴ・グラビティ", version: 1, category: "OTHER", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁻" }, artist: "モ～たん（CV：松井恵理子）" }, { musicId: 152, title: "忘却の旅路", version: 1, category: "OTHER", bpm: { min: 110, max: 110 }, chartsInfo: { light: "０１", medium: "０６", beast: "０９⁻" }, artist: "ピヨたん（CV：佐々木未来）" }, { musicId: 153, title: "ETMファイティングクライマックス！ 本気の師匠チャレンジ編", version: 1, category: "OTHER", bpm: { min: 136, max: 136 }, chartsInfo: { light: "０３", medium: "０６", beast: "０８" }, artist: "シマたん(CV:巽悠衣子)、ドラたん(CV:内田真礼)、ウリたん(CV:花守ゆみり)" }, { musicId: 154, title: "TRY！ TRY！ TRY！", version: 1, category: "OTHER", bpm: { min: 162, max: 162 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "シマたん（CV：巽悠衣子）" }, { musicId: 155, title: "さてこそ桃源郷", version: 1, category: "OTHER", bpm: { min: 88, max: 140 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "ドラたん（CV:内田真礼）" }, { musicId: 156, title: "激凸!?ウリティ☆ウリリズム", version: 1, category: "OTHER", bpm: { min: 216, max: 216 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "ウリたん（CV：花守ゆみり）" }, { musicId: 157, title: "最強プロデュース！めざせ干支ップ☆アイドル", version: 1, category: "OTHER", bpm: { min: 70, max: 200 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "ウサたん（CV:相坂優歌）、ウマたん（CV：小澤亜李）、キーたん（CV： 戸田めぐみ）、イヌたん（CV：本多真梨子）" }, { musicId: 158, title: "がんばれ♥ ウサ☆ウサPPプロデュース！", version: 1, category: "OTHER", bpm: { min: 186, max: 186 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "ウサたん（CV：相坂優歌）" }, { musicId: 159, title: "笑う門に午来る！", version: 1, category: "OTHER", bpm: { min: 172, max: 172 }, chartsInfo: { light: "０２", medium: "０４", beast: "０８" }, artist: "ウマたん（CV：小澤亜李）" }, { musicId: 160, title: "ふたりマイウェイ！", version: 1, category: "OTHER", bpm: { min: 240, max: 240 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁺" }, artist: "キーたん（CV：戸田めぐみ）、イヌたん（CV：本多真梨子）" }, { musicId: 161, title: "秘湯に願いを！今夜はホット・アンド・スイート", version: 1, category: "OTHER", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "チュウたん（CV：大原さやか）、シャアたん（CV：生天目仁美）、メイたん（CV：渕上舞）" }, { musicId: 162, title: "窮猫ハ鼠ヲモ嚙メズ", version: 1, category: "OTHER", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "チュウたん（CV：大原さやか）" }, { musicId: 163, title: "あなたの総集編", version: 1, category: "OTHER", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "シャアたん（CV：生天目仁美）" }, { musicId: 164, title: "TwinklePeace", version: 1, category: "OTHER", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "メイたん（CV：渕上舞）" }, { musicId: 165, title: "隅田川夏恋歌", version: 1, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺", nightmare: "１０" }, artist: "seiya-murai feat.ALT" }, { musicId: 166, title: "Sakura Sunrise", version: 1, category: "KDE", bpm: { min: 181, max: 181 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０⁻" }, artist: "Ryu☆" }, { musicId: 167, title: "虹色遊園地", version: 1, category: "KDE", bpm: { min: 165, max: 220 }, chartsInfo: { light: "０３", medium: "０９⁻", beast: "１０" }, artist: "Mutsuhiko Izumi VS DJ TOTTO" }, { musicId: 168, title: "ドッキン☆サマーあばんちゅーる", version: 1, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０⁻" }, artist: "L.E.D.-G ⁺ Qrispy Joybox ⁺ ARM feat. ななひら" }, { musicId: 169, title: "夏色DIARY BisCoの思い出（＞▽＜）", version: 1, category: "KDE", bpm: { min: 187, max: 187 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "猫叉王子 feat.Qrispy Joybox" }, { musicId: 170, title: "エクストラ・マジック・アワー ", version: 1, category: "ANIME", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "AKINO with bless4" }, { musicId: 171, title: "SPLASH FREE", version: 1, category: "ANIME", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "STYLE FIVE" }, { musicId: 172, title: "MURASAKI", version: 1, category: "OTHER", bpm: { min: 145, max: 145 }, chartsInfo: { light: "０３", medium: "０６", beast: "０８" }, artist: "蒼井翔太" }, { musicId: 173, title: "はなまるぴっぴはよいこだけ", version: 1, category: "ANIME", bpm: { min: 172, max: 172 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺", nightmare: "10-" }, artist: "A応P" }, { musicId: 174, title: "neko＊neko", version: 1, category: "KDE", bpm: { min: 123, max: 123 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "日向美ビタースイーツ♪" }, { musicId: 175, title: "漆黒のスペシャルプリンセスサンデー", version: 1, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "日向美ビタースイーツ♪" }, { musicId: 176, title: "残酷な天使のテーゼ", version: 2, category: "ANIME", bpm: { min: 79, max: 128 }, chartsInfo: { light: "０２", medium: "０６", beast: "０８" }, artist: "-" }, { musicId: 177, title: "紅蓮の弓矢", version: 2, category: "ANIME", bpm: { min: 180.66, max: 180.66 }, chartsInfo: { light: "０１", medium: "０６", beast: "０９⁻", nightmare: "10-" }, artist: "Linked Horizon" }, { musicId: 178, title: "太陽曰く燃えよカオス", version: 2, category: "ANIME", bpm: { min: 143, max: 143 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻", nightmare: "１０" }, artist: "後ろから這いより隊G" }, { musicId: 179, title: "Enigmatic Feeling", version: 2, category: "ANIME", bpm: { min: 142, max: 142 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁺" }, artist: "凛として時雨" }, { musicId: 180, title: "シュガーソングとビターステップ", version: 2, category: "ANIME", bpm: { min: 132, max: 132 }, chartsInfo: { light: "０２", medium: "０７", beast: "０９⁺", nightmare: "１０" }, artist: "UNISON SQUARE GARDEN" }, { musicId: 181, title: "COLORFUL BOX ", version: 2, category: "ANIME", bpm: { min: 161, max: 161 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁻" }, artist: "石田燿子" }, { musicId: 182, title: "宝箱-TREASURE BOX-", version: 2, category: "ANIME", bpm: { min: 162, max: 162 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "奥井雅美" }, { musicId: 183, title: "かくしん的☆めたまるふぉ〜ぜっ！", version: 2, category: "ANIME", bpm: { min: 133, max: 139 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺", nightmare: "１０" }, artist: "土間うまる（CV:田中あいみ）" }, { musicId: 184, title: "Twinbee's Home Town Song", version: 2, category: "KDE", bpm: { min: 168, max: 168 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁺" }, artist: "Sota Fujimori" }, { musicId: 185, title: "トキメキストリーム", version: 2, category: "KDE", bpm: { min: 164, max: 164 }, chartsInfo: { light: "０２", medium: "０７", beast: "１０", nightmare: "10⁺" }, artist: "Qrispy Joybox" }, { musicId: 186, title: "にゃんのパレードマーチ♪", version: 2, category: "KDE", bpm: { min: 162, max: 162 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "DJ TOTTO feat.にゃん" }, { musicId: 187, title: "アキネイション", version: 2, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 188, title: "秘密がーる♡乙女", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "MaMiKa（松下×mitsu×T.kakuta）" }, { musicId: 189, title: "ぱんだしんけん１、２、３ ～ちえ！おっしょさんにはかなわないや！～", version: 2, category: "KDE", bpm: { min: 158, max: 158 }, chartsInfo: { light: "０３", medium: "０８", beast: "０９⁺" }, artist: "おひさまくらぶ" }, { musicId: 190, title: "蟲の棲む処", version: 2, category: "KDE", bpm: { min: 161.51, max: 161.51 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "かめりあ feat. Nana Takahashi" }, { musicId: 191, title: "激アツ☆マジヤバ☆チアガール", version: 2, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０３", medium: "０７", beast: "０８" }, artist: "日向美ビタースイーツ♪" }, { musicId: 192, title: "打打打打打打打打打打", version: 2, category: "KDE", bpm: { min: 156, max: 156 }, chartsInfo: { light: "０３", medium: "０５", beast: "１０⁻", nightmare: "１０" }, artist: "ヒゲドライバー join. SELEN" }, { musicId: 193, title: "創聖のアクエリオン", version: 2, category: "ANIME", bpm: { min: 151, max: 151 }, chartsInfo: { light: "０１", medium: "０５", beast: "０８" }, artist: "-" }, { musicId: 194, title: "RPG", version: 2, category: "ANIME", bpm: { min: 135, max: 135 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "SEKAI NO OWARI" }, { musicId: 195, title: "患部で止まってすぐ溶ける ～ 狂気の優曇華院", version: 2, category: "TOHO", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "ARM(IOSYS)" }, { musicId: 196, title: "Grip & Break down !!", version: 2, category: "TOHO", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０⁻", nightmare: "１０" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 197, title: "究極焼肉レストラン！お燐の地獄亭！", version: 2, category: "TOHO", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "ARM(IOSYS)" }, { musicId: 198, title: "楽しい夜のお茶会 - Ringo's Tea Party", version: 2, category: "TOHO", bpm: { min: 175, max: 175 }, chartsInfo: { light: "０３", medium: "０５", beast: "０９⁻" }, artist: "ARM(IOSYS)" }, { musicId: 199, title: "幻想のサテライト", version: 2, category: "TOHO", bpm: { min: 230, max: 230 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "豚乙女" }, { musicId: 200, title: "Wheel", version: 2, category: "TOHO", bpm: { min: 136, max: 136 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "Syrufit feat.綾倉盟 / 市松椿" }, { musicId: 201, title: "Vampire Killer", version: 2, category: "KDE", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０３", medium: "０８", beast: "１０" }, artist: "浅田 靖" }, { musicId: 202, title: "GRADIUS 2012", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０５", medium: "０９⁻", beast: "１０" }, artist: "Sota Fujimori" }, { musicId: 203, title: "月風魔伝　～ ビーストメドレー ～", version: 2, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "Akhuta" }, { musicId: 204, title: "がんばれゴエモン　～ ビーストメドレー ～", version: 2, category: "KDE", bpm: { min: 113, max: 190 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁻" }, artist: "96" }, { musicId: 205, title: "分けるな危険！モモモモモモーイズム", version: 2, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０⁻" }, artist: "ARM×狐夢想 feat. 桃井はるこ" }, { musicId: 206, title: "CARNIVOROUS", version: 2, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０５", medium: "０９⁻", beast: "１０" }, artist: "SOUND HOLIC feat. Nana Takahashi" }, { musicId: 207, title: "地方創生☆チクワクティクス", version: 2, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 208, title: "リリーゼと炎龍レーヴァテイン", version: 2, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０５", medium: "０８", beast: "１０", nightmare: "10⁺" }, artist: "黒猫ダンジョン" }, { musicId: 209, title: "smooooch・∀・", version: 2, category: "KDE", bpm: { min: 177, max: 177 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "kors k" }, { musicId: 210, title: "Twinkle Wonderland", version: 2, category: "KDE", bpm: { min: 188, max: 188 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "Qrispy Joybox feat.Sana " }, { musicId: 211, title: "She is my wife", version: 2, category: "KDE", bpm: { min: 85, max: 170 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "SUPER STAR 満-MITSURU-" }, { musicId: 212, title: "ほしふり", version: 2, category: "KDE", bpm: { min: 155, max: 155 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "Sana" }, { musicId: 213, title: "梅雪夜", version: 2, category: "KDE", bpm: { min: 167, max: 167 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０", nightmare: "10⁺" }, artist: "Qrispy Joybox feat.mao" }, { musicId: 214, title: "絶品☆みこみこミラクル昇天レシピ！", version: 2, category: "OTHER", bpm: { min: 204, max: 204 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "MOSAIC.WAV & miko(Alternative ending)" }, { musicId: 215, title: "GRADIUS Ⅱ　～ ビーストメドレー ～", version: 2, category: "KDE", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "Sota Fujimori" }, { musicId: 216, title: "キミとワタシのオンガク", version: 2, category: "KDE", bpm: { min: 160, max: 160 }, chartsInfo: { light: "０２", medium: "０６", beast: "１０⁻" }, artist: "seiya-murai feat. ALT" }, { musicId: 217, title: "量子の海のリントヴルム", version: 2, category: "KDE", bpm: { min: 280, max: 280 }, chartsInfo: { light: "０５", medium: "０９", beast: "１０", nightmare: "10⁺" }, artist: "黒猫ダンジョン" }, { musicId: 218, title: "混ぜるな危険", version: 2, category: "ANIME", bpm: { min: 178, max: 178 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "筋肉少女帯" }, { musicId: 219, title: "Sky High", version: 2, category: "KDE", bpm: { min: 153, max: 153 }, chartsInfo: { light: "０５", medium: "０９⁺", beast: "１０⁺", nightmare: "ネ申" }, artist: "Cuvelia" }, { musicId: 220, title: "SPACE VILLAGE", version: 2, category: "KDE", bpm: { min: 170, max: 170 }, chartsInfo: { light: "０２", medium: "０６", beast: "１０⁻" }, artist: "サイバー劇レコ" }, { musicId: 221, title: "全力バタンキュー", version: 2, category: "ANIME", bpm: { min: 155, max: 155 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９" }, artist: "A応P" }, { musicId: 222, title: "きゅん×きゅんばっきゅん☆LOVE", version: 2, category: "KDE", bpm: { min: 165, max: 165 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９" }, artist: "松下feat.Sota & wac" }, { musicId: 223, title: "CHERNOBOG", version: 2, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０５", medium: "０９", beast: "１０⁺", nightmare: "ネ申" }, artist: "漆黒のEBONY" }, { musicId: 224, title: "spring pony", version: 2, category: "KDE", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９" }, artist: "S-C-U" }, { musicId: 225, title: "繚乱ヒットチャート", version: 2, category: "KDE", bpm: { min: 192, max: 192 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "ギラギラメガネ団" }, { musicId: 226, title: "Spring Comes Around (In Like a Lion)", version: 2, category: "KDE", bpm: { min: 159.5, max: 159.5 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "Sota Fujimori Rmx by wac" }, { musicId: 227, title: "アルストロメリア", version: 2, category: "KDE", bpm: { min: 144, max: 144 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０" }, artist: "TAG" }, { musicId: 228, title: "Sakura Reflection", version: 2, category: "KDE", bpm: { min: 181, max: 181 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "Ryu☆" }, { musicId: 229, title: "黒髪乱れし修羅となりて～凛 edition～", version: 2, category: "KDE", bpm: { min: 300, max: 300 }, chartsInfo: { light: "０４", medium: "０６", beast: "０９⁺", nightmare: "１０" }, artist: "日向美ビタースイーツ♪" }, { musicId: 230, title: "Clattanoia", version: 2, category: "ANIME", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "OxT" }, { musicId: 231, title: "クローバー♣かくめーしょん", version: 2, category: "ANIME", bpm: { min: 145, max: 145 }, chartsInfo: { light: "０２", medium: "０５", beast: "０８" }, artist: "とりぷる♣ふぃーりんぐ(和久井 優／金澤まい／今村彩夏)" }, { musicId: 232, title: "Knew day", version: 2, category: "ANIME", bpm: { min: 150, max: 150 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "(K)NoW_NAME" }, { musicId: 233, title: "からくりピエロ", version: 2, category: "EXITTUNES", bpm: { min: 102, max: 102 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "40ｍP" }, { musicId: 234, title: "華鳥風月", version: 2, category: "TOHO", bpm: { min: 123, max: 123 }, chartsInfo: { light: "０２", medium: "０５", beast: "０９⁻" }, artist: "幽閉サテライト" }, { musicId: 235, title: "人間が大好きなこわれた妖怪の唄", version: 2, category: "TOHO", bpm: { min: 166, max: 166 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁻" }, artist: "ビートまりお（COOL&CREATE）" }, { musicId: 236, title: "忌憚騒命曲 ～ Demon tale sonata", version: 2, category: "TOHO", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "どぶウサギ（dBu music）" }, { musicId: 237, title: "キャプテン・ムラサのケツアンカー", version: 2, category: "TOHO", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０４", medium: "０７", beast: "０９⁺" }, artist: "ARM⁺夕野ヨシミ feat.山本椛" }, { musicId: 238, title: "Power of Battle（vs REDALiCE）", version: 2, category: "TOHO", bpm: { min: 178, max: 178 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "RoughSketch vs REDALiCE feat.イザベル" }, { musicId: 239, title: "鈴瑚のお団子ジャングルジム", version: 2, category: "TOHO", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９" }, artist: "ARM⁺狐夢想 feat.ななひら" }, { musicId: 240, title: "wandering to sweet", version: 2, category: "TOHO", bpm: { min: 154, max: 154 }, chartsInfo: { light: "０３", medium: "０５", beast: "０９⁻" }, artist: "平茸⁺夕野ヨシミ feat.山本椛" }, { musicId: 241, title: "Lost wing at.0", version: 2, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "猫叉Master⁺" }, { musicId: 242, title: "ロプノールの商隊", version: 2, category: "KDE", bpm: { min: 186, max: 186 }, chartsInfo: { light: "０２", medium: "０６", beast: "１０" }, artist: "Akhuta" }, { musicId: 243, title: "Phlox", version: 2, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０４", medium: "０８", beast: "１０⁻" }, artist: "Sota Fujimori 2nd Season" }, { musicId: 244, title: "Dynasty", version: 2, category: "KDE", bpm: { min: 189, max: 189 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "Yooh" }, { musicId: 245, title: "じゅーじゅー♥焼肉の火からフェニックス！？～再誕の†炭火焼き～", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０４", medium: "０９⁻", beast: "１０" }, artist: "かめりあ feat. ななひら" }, { musicId: 246, title: "雪女", version: 2, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０２", medium: "０７", beast: "１０" }, artist: "かねこちはる" }, { musicId: 247, title: "フラッター現象の顛末と単一指向性の感情論", version: 2, category: "KDE", bpm: { min: 206, max: 206 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９" }, artist: "日向美ビタースイーツ♪" }, { musicId: 248, title: "Good bye, Summer～さよならは言わない～", version: 2, category: "KDE", bpm: { min: 165, max: 165 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９" }, artist: "私立BEMANI学園軽音部 OB" }, { musicId: 249, title: "スカイダイバー", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０５", medium: "０７", beast: "０９" }, artist: "ヒゲドライバー feat.ヒゲドライVAN" }, { musicId: 250, title: "週替わりの奇跡の神話", version: 2, category: "ANIME", bpm: { min: 169, max: 169 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９" }, artist: "筋肉少女帯" }, { musicId: 251, title: "GO! GO! MANIAC", version: 2, category: "ANIME", bpm: { min: 250, max: 250 }, chartsInfo: { light: "０４", medium: "０８", beast: "０９⁺" }, artist: "放課後ティータイム" }, { musicId: 252, title: "最高速 Fall in Love", version: 2, category: "ANIME", bpm: { min: 132, max: 175 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "ミーア、パピ、セントレア、スー、メロ、ラクネラ" }, { musicId: 253, title: "ハッピーシンセサイザ", version: 2, category: "OTHER", bpm: { min: 127, max: 127 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "EasyPop" }, { musicId: 254, title: "東京テディベア", version: 2, category: "OTHER", bpm: { min: 204, max: 204 }, chartsInfo: { light: "０３", medium: "０７", beast: "０９⁺" }, artist: "Neru" }, { musicId: 255, title: "ケンぱ！ケンぱ！拳拳ぱん打！", version: 2, category: "KDE", bpm: { min: 200, max: 200 }, chartsInfo: { light: "０３", medium: "０６", beast: "１０⁻" }, artist: "ぱんぱんぱん打" }, { musicId: 256, title: "Lost wing at.0", version: 2, category: "KDE", bpm: { min: 185, max: 185 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "猫叉Master⁺" }, { musicId: 257, title: "朧", version: 2, category: "KDE", bpm: { min: 149, max: 149 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０" }, artist: "HHH×MM×ST" }, { musicId: 258, title: "恋はどう？モロ◎波動OK☆方程式！！", version: 2, category: "KDE", bpm: { min: 128, max: 128 }, chartsInfo: { light: "０５", medium: "０９⁻", beast: "１０" }, artist: "あべにゅうぷろじぇくと feat.佐倉紗織 produced by ave;new" }, { musicId: 259, title: "恋歌疾風！かるたクイーンいろは", version: 2, category: "KDE", bpm: { min: 120, max: 168 }, chartsInfo: { light: "０４", medium: "０９", beast: "１０⁺" }, artist: "ねこまんまチーム！" }, { musicId: 260, title: "SAKURAスキップ", version: 2, category: "ANIME", bpm: { min: 165, max: 165 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９" }, artist: "fourfolium" }, { musicId: 261, title: "Now Loading!!!!", version: 2, category: "ANIME", bpm: { min: 193, max: 193 }, chartsInfo: { light: "０３", medium: "０５", beast: "０９⁻" }, artist: "fourfolium" }, { musicId: 262, title: "カケラ", version: 2, category: "KDE", bpm: { min: 182, max: 182 }, chartsInfo: { light: "０５", medium: "０７", beast: "０９⁺" }, artist: "豚乙女" }, { musicId: 263, title: "怒りと共に去りぬ！！", version: 2, category: "KDE", bpm: { min: 190, max: 190 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻" }, artist: "96 feat.すわひでお" }, { musicId: 264, title: "在るが儘に", version: 2, category: "KDE", bpm: { min: 181, max: 181 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "Des-ROW・組スペシアルr" }, { musicId: 265, title: "Daisuke", version: 2, category: "KDE", bpm: { min: 157, max: 157 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０" }, artist: "Y&Co." }, { musicId: 266, title: "JOMANDA", version: 2, category: "KDE", bpm: { min: 90, max: 300 }, chartsInfo: { light: "０５", medium: "０９", beast: "１０⁺" }, artist: "DJ YOSHITAKA" }, { musicId: 267, title: "サヨナラ・ヘヴン", version: 2, category: "KDE", bpm: { min: 111, max: 111 }, chartsInfo: { light: "０２", medium: "０６", beast: "０９⁺" }, artist: "猫叉Master" }, { musicId: 268, title: "轟け！恋のビーンボール！！", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０３", medium: "０７", beast: "１０⁻", nightmare: "10⁺" }, artist: "ダイナミック野球兄弟 v.s. クロスファイヤーPrim" }, { musicId: 269, title: "少年リップルズ", version: 2, category: "KDE", bpm: { min: 210, max: 210 }, chartsInfo: { light: "０４", medium: "０７", beast: "１０⁻" }, artist: "常盤ゆう" }, { musicId: 270, title: "たまゆら", version: 2, category: "KDE", bpm: { min: 180, max: 180 }, chartsInfo: { light: "０４", medium: "０６", beast: "０９⁺" }, artist: "佐々木博史" }, { musicId: 271, title: "quaver♪", version: 2, category: "KDE", bpm: { min: 182, max: 186 }, chartsInfo: { light: "０５", medium: "０８", beast: "１０⁺" }, artist: "Risk Junk" }, { musicId: 272, title: "SigSig", version: 2, category: "KDE", bpm: { min: 179, max: 179 }, chartsInfo: { light: "０３", medium: "０６", beast: "０９⁺" }, artist: "kors k" }] + let courseTitle = ["RANK 01","RANK 02","RANK 03","RANK 04","RANK 05","RANK 06","RANK 07","RANK 08","RANK 09","RANK 10","RANK 11","RANK 12","RANK 13","RANK 14","RANK 15","RANK ネ申"] + let bstChartTypeDetails = [{title:"Light",color:"#2EBECC",colorInvert:"#2EBECC"},{title:"Medium",color:"#F2C40B",colorInvert:"#F2C40B"},{title:"Beast",color:"#FF3860",colorInvert:"#FF3860"},{title:"Nightmare",color:"#000000",colorInvert:"#00DDDD"},] + + let defaultPageSize = 20 + +//- Processing +- + bst2Course.sort((l, r) => r.courseId - l.courseId) + bst2StageLog.sort((l, r) => r.time - l.time) + if (bst2Account != null) { + let checkUserId = (col) => { + let removeList = [] + for (i = 0; i < col.length; i++) if (col[i].userId != bst2Account.userId) removeList.push(i) + for (let i of removeList) col.splice(i, 1) + } + checkUserId(bst2Course) + checkUserId(bst2MusicRecord) + checkUserId(bst2CourseLog) + checkUserId(bst2StageLog) + } + + let bst2MusicRecordOrganized = [] + for (let r of bst2MusicRecord) { + let o = bst2MusicRecordOrganized[r.musicId] + if (o == null) o = {} + o[r.chart] = r + bst2MusicRecordOrganized[r.musicId] = o + } + +//- Play data +- + let bst2HighestRank = -1 + for (let r of bst2Course) if ((r.courseId > bst2HighestRank) && (r.medal >= 3)) bst2HighestRank = r.courseId + function getClearTypeDetails(record) { + if (record.medal == 5) return { title: "Perfect", abbr: "P", color: "#FF3860; text-shadow: 0 0 5px #FFFFFF9F;", badge: "mdi mdi-decagram mdi-48px" } + else if (record.medal == 4) return { title: "Full Combo", abbr: "FC", color: "gold", badge: "mdi mdi-cog mdi-48px" } + else if (record.medal == 3) return { title: "Clear", abbr: "C", color: "#33E7AD", badge: "mdi mdi-star-circle-outline mdi-48px"} + else if ((record.medal == 2) || (record.medal == 1)) return { title: "Failed", abbr: "F", color: "#837E8D", badge: "mdi mdi-close-circle-outline mdi-48px"} + else return null + } + function getRank(score, version) { + if ((score >= 970000) && (version == 2)) return { title: "AAA", color: "#FF3860", colorInvert: "#FF3860" } + else if (score >= 950000) return { title: "AAA", color: "black", colorInvert: "gold" } + else if (score >= 850000) return { title: "AA", color: "black", colorInvert: "gold" } + else if (score >= 700000) return { title: "A", color: "black", colorInvert: "gold" } + else if (score >= 600000) return { title: "B", color: "black", colorInvert: "#40FEAA" } + else if (score >= 500000) return { title: "C", color: "black", colorInvert: "#40FEAA" } + else return { title: "D", color: "black", colorInvert: "#837E8D" } + } + +link(rel="stylesheet", href="static/css/webui_util.css", type="text/css") +script(src = "static/js/webui_util.js") +.modal.loading.is-active + .modal-background(style = "opacity: 50%") + p(style = "position: fixed; bottom: 40px; right: 40px; color: white") + span Now Loading... + i.mdi.mdi-refresh-circle.mdi-spin +div + if (webuiMessage != null) && ((webuiMessage.refid == null) || (webuiMessage.refid == refid)) + div(class = "notification temporary" + ((webuiMessage.type == 0) ? " is-info" : (webuiMessage.type == 1) ? " is-success" : " is-danger"), style = "display: block") + .delete(style = "margin-top: 10px") + span #{webuiMessage.message} + form.start(method="post" action="/emit/removeWebUIMessage", style = "display: none") + .columns.is-mobile.is-vcentered(style = "overflow-x: auto") + .column + .column.is-narrow + p.is-size-7 Select game version + .column.is-narrow + style. + .tabs.is-toggle li a, .tabs.is-toggle li a span, .tabs.is-toggle li a span span, .tabs.is-toggle li a div, .tabs.is-toggle li a .background { + transition: .2s linear, font-weight 0s linear; + } + .tabs.is-toggle ul li.is-active[tab-group="version"][tab-index="2"] a { + background-color: black; + color: white; + font-weight: bold; + text-shadow: 0 1.5px 0 #D0D09A; + border-color: black; + } + .tabs.is-toggle ul li.is-active[tab-group="version"][tab-index="2"] a span { + transform: skewX(-12deg); + } + .tabs.is-toggle.is-toggle-rounded.is-small#tabs + ul(style = "margin: 0") + li.disabled(tab-group = "version", tab-index = "1", style = "width: 112px", title = "Coming s∞n...") + a BeatStream + li(tab-group = "version", tab-index = "2", style = "width: 112px", class = (defaultVersion == 2) ? "is-active" : "") + a + span アニムトライヴ + .card + header.card-header + p.card-header-title + span.icon + i.mdi.mdi-account-circle + | Play Data + a.card-header-icon.card-toggle(card = "play-data") + span.icon + i.mdi.mdi-chevron-down + .card-content(card = "play-data") + #tab-content(tab-group = "version", tab-index = "2", class = (defaultVersion == 2) ? "is-active" : "") + if bst2Account == null + .has-text-grey.has-text-centered + p + span.icon.is-large + i.mdi.mdi-emoticon-happy.mdi-48px + p Nothing's here yet. Let's play! + else + .tabs#tabs + ul + li.is-active(tab-group = "bst2-play-data", tab-index = "0") + a Overview + li(tab-group = "bst2-play-data", tab-index = "1") + a Scores + li(tab-group = "bst2-play-data", tab-index = "2") + a Course + li(tab-group = "bst2-play-data", tab-index = "3") + a Play History + #tab-content.is-active(tab-group = "bst2-play-data", tab-index = "0") + .field.is-horizontal + .field-label + label.label User ID + .field-body + span #{bst2Account.userId.toString().padStart(8, "0").slice(0, 4)}-#{bst2Account.userId.toString().padStart(8, "0").slice(4, 8)} + .field.is-horizontal + .field-label + label.label Name + .field-body + span #{bst2Base.name} + .field.is-horizontal + .field-label + label.label Play Count + .field-body + span #{bst2Account.playCount} + .field.is-horizontal + .field-label + label.label Beast Rank + .field-body + if bst2Base.brnk == 0 + span - + else + span #{courseTitle[bst2Base.brnk - 1]} + #tab-content(tab-group = "bst2-play-data", tab-index = "1", style = "overflow-x: auto; overflow-y: hidden") + if bst2MusicRecord.length == 0 + .has-text-grey.has-text-centered + p + span.icon.is-large + i.mdi.mdi-emoticon-happy.mdi-48px + p Nothing's here yet. Let's play! + else + .paginated-container(pagination-group = "bst2-scores") + input.page-size(type = "hidden", value = defaultPageSize) + .hidden-wrapper + .pagination + a.pagination-previous + i.mdi.mdi-chevron-left + | Previous + a.pagination-next + | Next + i.mdi.mdi-chevron-right + ul.pagination-list#tabs + .scrolling-x-wrapper.hidden-y-wrapper + table.table(style = "vertical-align: middle") + thead + tr + th ID + th(stye = "width: 250px") Title + th Scores + tbody + each r in bst2MusicRecordOrganized + if r != null + - let easiestChart = 4 + - for (let k in r) if ((parseInt(k).toString() == k) && (parseInt(k) < easiestChart)) easiestChart = parseInt(k) + - let info = bstMusicsInfo[r[easiestChart].musicId] + tr.is-vcentered.paginated-content + td(style = "white-space: nowrap; overflow: hidden; text-overflow: ellipsis; vertical-align: middle;") #{r[easiestChart].musicId} + td(style = "width: 250px; vertical-align: middle") + .marquee-label-container(style = "max-width: 250px;") + span.modal-trigger + a.marquee-label(style = "display: inline-block") #{info.title} + .modal.is-mobile + .modal-background.is-mobile#close + .modal-card.is-mobile(style = "vertical-align: middle; margin-top: 65px") + header.modal-card-head + p.modal-card-title(style = "margin-bottom: 0") Details + button.delete#close + section.modal-card-body + table.table + thead + tr + th + each i in [0, 1, 2, 3] + th(style = "width: 120px; color: " + bstChartTypeDetails[i].color) #{bstChartTypeDetails[i].title} + tbody + tr + th Music ID + td(colspan = "4") #{info.musicId} + tr + th Title + td(colspan = "4", style = "white-space: normal;") #{info.title} + tr + th Artist + td(colspan = "4", style = "white-space: normal;") #{info.artist} + tr + th BPM + td(colspan = "4") #{info.bpm.min + ((info.bpm.max == info.bpm.min) ? "" : (" - " + info.bpm.max))} + tr + th Level + each i in [0, 1, 2, 3] + - let t = bstChartTypeDetails[i] + if info.chartsInfo[t.title.toLowerCase()] != null + td(style = "color: " + ((info.chartsInfo[t.title.toLowerCase()] == "ネ申") ? "gold; text-shadow: 0 0 3px gold;" : t.color)) #{info.chartsInfo[t.title.toLowerCase()]} + else + td + tr + th State + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + td + abbr(title = d.title) #{d.abbr} + else + td + tr + th Rank + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + - let rank = getRank(c.score, 2) + td(style = "color: " + rank.color) #{rank.title} + else + td + tr + th Score + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + td #{c.score} + else + td + tr + th Combo + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + td #{c.combo} + else + td + tr + th Update + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + td #{new Date(c.updateTime).toLocaleString().split(" ")[0]} + else + td + tr + th Last Play + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chartType] + td #{new Date(c.lastPlayTime).toLocaleString().split(" ")[0]} + else + td + footer.modal-card-foot + td + .columns.is-mobile + each i in [0, 1, 2, 3] + if (r[i] != null) && (getClearTypeDetails(r[i]) != null) + - let c = r[i] + - let d = getClearTypeDetails(c) + - let t = bstChartTypeDetails[c.chart] + .column.is-one-quarter.modal-trigger(style = "vertical-align: middle;") + a.one-quarter#forwide(style = "min-width: 120px") + .heading.has-text-centered(style = "white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: " + t.color) #{t.title} + .title.has-text-centered(style = "white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: " + t.color) #{c.score} + a.one-quarter.has-text-centered#fornarrow(style = "white-space: nowrap; overflow: hidden; min-width: 60px; color: " + t.color) #{c.score} + .modal.is-mobile + .modal-background.is-mobile#close + .modal-card.is-mobile(style = "vertical-align: middle; margin-top: 65px") + header.modal-card-head + p.modal-card-title(style = "margin-bottom: 0") Details + button.delete#close + section.modal-card-body + .form + .field.is-horizontal + .field-label + label.label Music ID + .field-body + span #{c.musicId} + .field.is-horizontal + .field-label + label.label Music Title + .field-body + span #{info.title} + .field.is-horizontal + .field-label + label.label Artist + .field-body + span #{info.artist} + .field.is-horizontal + .field-label + label.label BPM + .field-body + span #{info.bpm.min + ((info.bpm.max == info.bpm.min) ? "" : (" - " + info.bpm.max))} + .field.is-horizontal + .field-label + label.label Chart + .field-body + .level.is-mobile + .level-left + .level-item + span(style = "color: " + t.color) #{t.title} + .level-item + p(style = "color: " + ((info.chartsInfo[t.title.toLowerCase()] == "ネ申") ? "gold; text-shadow: 0 0 3px gold;" : t.color)) #{info.chartsInfo[t.title.toLowerCase()]} + .field.is-horizontal + .field-label + label.label State + .field-body + span #{d.title} + .field.is-horizontal + .field-label + label.label Rank + .field-body + span(style = "color: " + getRank(c.score, 2).color) #{getRank(c.score, 2).title} + .field.is-horizontal + .field-label + label.label Score + .field-body + span #{c.score} + .field.is-horizontal + .field-label + label.label Combo + .field-body + span #{c.combo} + .field.is-horizontal + .field-label + label.label(style = "white-space: nowrap; vertical-align: middle;") Update Time + .field-body + span #{new Date(c.updateTime).toLocaleString()} + .field.is-horizontal + .field-label + label.label(style = "white-space: nowrap; vertical-align: middle;") Last Play + .field-body + span #{new Date(c.lastPlayTime).toLocaleString()} + footer.modal-card-foot + else + .column.is-one-quarter + a.one-quarter#forwide(style = "min-width: 120px") + a.one-quarter#fornarrow(style = "min-width: 120px") + .hidden-wrapper + .pagination + a.pagination-previous + i.mdi.mdi-chevron-left + | Previous + a.pagination-next + | Next + i.mdi.mdi-chevron-right + ul.pagination-list#tabs + #tab-content(tab-group = "bst2-play-data", tab-index = "2", style = "overflow-x: auto") + if bst2Course.length == 0 + .has-text-grey.has-text-centered + p + span.icon.is-large + i.mdi.mdi-emoticon-happy.mdi-48px + p Nothing's here yet. Let's play! + else + table.table + thead + tr + th Course + th State + th Score + th Combo + th Gauge + th Play Count + th Update Time + th Last Play Time + tbody + each c in bst2Course + tr + td(style = "white-space: nowrap;") #{courseTitle[c.courseId]} + td #{getClearTypeDetails(c).title} + td #{c.score} + td #{c.combo} + td #{(c.gauge / 10).toFixed(1)}% + td #{c.playCount} + td #{new Date(c.updateTime).toLocaleString()} + td #{new Date(c.lastPlayTime).toLocaleString()} + #tab-content(tab-group = "bst2-play-data", tab-index = "3", style = "overflow-x: auto") + if bst2StageLog.length == 0 + .has-text-grey.has-text-centered + p + span.icon.is-large + i.mdi.mdi-emoticon-happy.mdi-48px + p Nothing's here yet. Let's play! + else + .paginated-container(pagination-group = "bst2-play-history") + input.page-size(type = "hidden", value = defaultPageSize) + .hidden-wrapper + .pagination + a.pagination-previous + i.mdi.mdi-chevron-left + | Newer + a.pagination-next + | Older + i.mdi.mdi-chevron-right + ul.pagination-list#tabs + .scrolling-wrapper + table.table + thead + th ID + th(style = "max-width: 200px") Title + th Chart + th Level + th State + th Score + th Scene + th Time + tbody + - + let progresspattern = "" + for (i = 0; i <= 24; i++) progresspattern += "transparent " + (i * 4 + 2) + "%, #FFFFFF4F " + (i * 4 + 2) + "%, #FFFFFF4F " + (i * 4 + 3) + "%, transparent " + (i * 4 + 3) + ((i != 24) ? "%, " : "%") + each s in bst2StageLog + - let info = bstMusicsInfo[s.musicId] + - let chart = bstChartTypeDetails[s.chart] + - let level = info.chartsInfo[chart.title.toLowerCase()] + - let rank = getRank(s.score, 2) + - let clearType = getClearTypeDetails(s) + tr.paginated-content + td #{s.musicId} + td(style = "max-width: 250px") + .marquee-label-container(style = "max-width: 250px;") + span.modal-trigger + a.marquee-label #{info.title} + .modal.is-mobile(style = "x-overflow: auto;") + .modal-background.is-mobile#close + .modal-content + .box(style = "background-color: black; color: white; border-radius: 12px; min-width: 600px") + p.has-text-centered(style = "border-bottom: 3px solid grey") #{info.title} + .columns.is-mobile + .column.is-narrow + .has-text-centered(style = "width: 256px; height: 256px; background-color: lightgrey; color: darkgray; border-radius: 3%; border: 3px solid " + chart.colorInvert) + p Should be a jacket here... + .level.is-mobile + .level-left + .level-right + .level-item(style = "color: " + chart.colorInvert) #{chart.title} + .level-item.is-size-4(style = (level == "ネ申") ? "color: gold; text-shadow: 0 0 5px gold" : "") #{level} + .column + .columns.is-vcentered.is-mobile(style = "margin-bottom: 0") + .column + - + let leftProgress = (s.gaugeTimes10 >= 700) ? "70%" : ((s.gaugeTimes10 / 10) + "%") + let rightProgress = (s.gaugeTimes10 < 700) ? "0" : (((s.gaugeTimes10 - 700) / 10) + "%") + .mulprogress(style = "width: 100%; height: 16px; border-radius: 8px; overflow: hidden; position: relative;") + .leftprogress(style = "float: left; height: 100%; border-radius: 8px 0 0 8px; background-color: #2EBECC; width: " + leftProgress) + .rightprogress(style = "float: left; height: 100%; background-color: #F151F1; width: " + rightProgress) + .forepattern(style = "position: absolute; top: 0; left: 0; bottom: 0; right: 0; background: linear-gradient(315deg, " + progresspattern + ")") + .column.is-narrow + p(style = "width: 60px") #{(s.gaugeTimes10 / 10).toFixed(1)}% + div(style = "margin-bottom: 28px; border-bottom: 3px dashed grey;") + .columns.is-vcentered.is-mobile + .column.is-narrow + p Score + .column.has-text-right + p.is-size-1 #{s.score.toString().padStart(7, "0")} + .box.is-size-7(style = "margin-bottom: 0; padding: 8px; background: black; color: white; box-shadow: 0 3px 4px #FFFFFF9F, 0 0 0 2px #FFFFFF3F;") + .columns.is-vcentered.is-mobile.has-text-centered(style = "margin-bottom: 0") + - let f = (bst2Customization.custom[7] | 0b00000001) == bst2Customization.custom[7] + .column.is-one-quarter + if f + span(style = "color: #FF6FC9") F + span(style = "color: #FFC90A") a + span(style = "color: #E7FF18") n + span(style = "color: #57FD4D") t + span(style = "color: #1BFCD7") a + span(style = "color: #1CD2FF") s + span(style = "color: #7255FB") t + span(style = "color: #A835F9") i + span(style = "color: #D512E8") c + else + span(style = "color: #EF005B") サ + span(style = "color: #37FFC8") イ + span(style = "color: #FFEE5F") コ + span(style = "color: #EF005B") ー + span(style = "color: #37FFC8") ！ + p #{(s.fantasticCount != null) ? s.fantasticCount.toString().padStart(4, "0") : "----"} + .column.is-one-quarter + if f + span(style = "color: #33E7AD") Great + else + span(style = "color: #37FFC8") ヨッシャー + p #{(s.greatCount != null) ? s.greatCount.toString().padStart(4, "0") : "----"} + .column.is-one-quarter + if f + span(style = "color: #FFC500") Fine + else + span(style = "color: #FFEE5F") オシイ + p #{(s.fineCount != null) ? s.fineCount.toString().padStart(4, "0") : "----"} + .column.is-one-quarter + if f + span(style = "color: #EF005B") miss + else + span(style = "color: #FF1D48; font-weight: bold; -webkit-text-stroke: 0.8px black; text-shadow: 0 0 1px #FF1D48, 0 0 1px #FF1D48, 0 0 1px #FF1D48, 0 0 1px #FF1D48") スカッ + p #{(s.missCount != null) ? s.missCount.toString().padStart(4, "0") : "----"} + .columns.is-vcentered.is-mobile + .column.is-one-quarter + .column.is-half.has-text-right + p Max Combo + .column.is-one-quarter.has-text-centered + p #{s.combo.toString().padStart(4, "0")} + .columns.is-vcentered.is-mobile + .column + .column.is-half.has-text-right(style = "position: relative") + div.has-text-centered(style = "position: absolute; transform: rotate(20deg) scale(0.7); top: 28px; right: -8px; color: " + clearType.color) + span(style = "position: relative; z-index: 1; background: white; padding: 0 8px; clip-path: polygon(0 10%, 100% 10%, 90% 47%, 100% 85%, 0 85%, 10% 47%);") #{clearType.title} + i(class = clearType.badge, style = "position: absolute; top: -22px; left: 2px; right: 2px; z-index: 0;") + p(style = "font-size: 3.8rem; color: " + rank.colorInvert) #{rank.title} + td(style = "color: " + chart.color) #{chart.title} + td(style = (level == "ネ申") ? "color: gold; text-shadow: 0 0 5px gold" : ("color: " + chart.color)) #{level} + td + abbr(title = clearType.title) #{clearType.abbr} + td #{s.score} + td #{s.stageId + 1} + td #{new Date(s.time).toLocaleString()} + .hidden-wrapper + .pagination + a.pagination-previous + i.mdi.mdi-chevron-left + | Newer + a.pagination-next + | Older + i.mdi.mdi-chevron-right + ul.pagination-list#tabs + .card + .card-header + p.card-header-title + span.icon + i.mdi.mdi-account-edit + | Player Settings + a.card-header-icon.card-toggle(card = "edit-settings") + span.icon + i.mdi.mdi-chevron-down + .card-content(card = "edit-settings") + #tab-content(tab-group = "version", tab-index = "2", class = (defaultVersion == 2) ? "is-active" : "") + if bst2Account == null + .has-text-grey.has-text-centered + p + span.icon.is-large + i.mdi.mdi-emoticon-happy.mdi-48px + p Nothing's here yet. Let's play! + else + form#validatable(method="post" action="/emit/bst2UpdateSettings") + input(type = "hidden", name = "refid", value = refid) + .field.is-horizontal#validatable + .field-label.is-normal + label.label Name + .field-body + .control + input.input#validatable(type = "text", name = "name", min-length = "1", max-length = "8", min-pattern = "^[a-zA-Z0-9\.\-_·・&!\?/\*#♯♭★@♪↓↑→←()∞◆●▼￥∀^ ]{1,8}$", value = bst2Base.name) + p.help 1~8 letter(s) and symbol(s). + .field.is-horizontal + .field-label.is-normal + label.label Ripple Note + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "rippleNote", value = bst2Customization.custom[0]) + .select + select#form-select-select + option Default + option Biggger + option Drop + option Shutter + .field.is-horizontal + .field-label.is-normal + label.label Normal Note Sound + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxNormalNote", value = bst2Customization.custom[2]) + .select + select#form-select-select + option Normal Set A + option Ripple Set A + option Slash Set A + option Stream Set A + option Normal Set B + option Ripple Set B + option Slash Set B + option Stream Set B + option Normal Set C + option Ripple Set C + option Slash Set C + option Stream Set C + .field.is-horizontal + .field-label.is-normal + label.label Ripple Note Sound + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxRippleNote", value = bst2Customization.custom[3]) + .select + select#form-select-select + option Normal Set A + option Ripple Set A + option Slash Set A + option Stream Set A + option Normal Set B + option Ripple Set B + option Slash Set B + option Stream Set B + option Normal Set C + option Ripple Set C + option Slash Set C + option Stream Set C + .field.is-horizontal + .field-label.is-normal + label.label Slash Note Sound + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxSlashNote", value = bst2Customization.custom[4]) + .select + select#form-select-select + option Normal Set A + option Ripple Set A + option Slash Set A + option Stream Set A + option Normal Set B + option Ripple Set B + option Slash Set B + option Stream Set B + option Normal Set C + option Ripple Set C + option Slash Set C + option Stream Set C + .field.is-horizontal + .field-label.is-normal + label.label Stream Note Sound + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxStreamNote", value = bst2Customization.custom[5]) + .select + select#form-select-select + option Normal Set A + option Ripple Set A + option Slash Set A + option Stream Set A + option Normal Set B + option Ripple Set B + option Slash Set B + option Stream Set B + option Normal Set C + option Ripple Set C + option Slash Set C + option Stream Set C + .field.is-horizontal + .field-label.is-normal + label.label Background Brightness + .field-body + .field.has-addons#form-numeric + .control + button.button.is-light#form-numeric-sub(type = "button") ＋ + .control + input.input#form-numeric-input(name = "backgroundBrightness", type = "hidden", min-value = "0", max-value = "200", step = "1", value = bst2Customization.custom[6] readonly) + input.input#form-numeric-input(style = "width: 72px; text-align: center", min-value = "100.0", max-value = "0.0", step = "-0.5", digit-count = "1", value = 100 - bst2Customization.custom[6] * 0.5, readonly) + .control + button.button.is-light#form-numeric-add(type = "button") － + .field.is-horizontal + .field-label.is-normal + label.label Judge Text + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "judgeText", value = ((bst2Customization.custom[7] | 0b00000001) == bst2Customization.custom[7]) ? 1 : 0) + .select + select#form-select-select + option Bst2 // サイコー！ + option Bst1 // Fantastic + .field.is-horizontal + .field-label.is-normal + label.label Ripple Note Prompt + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "rippleNoteGuide", value = ((bst2Customization.custom[7] | 0b00000010) == bst2Customization.custom[7]) ? 1 : 0) + .select + select#form-select-select + option On + option Off + .field.is-horizontal + .field-label.is-normal + label.label Stream Note Prompt + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "streamNoteGuide", value = ((bst2Customization.custom[7] | 0b00000100) == bst2Customization.custom[7]) ? 1 : 0) + .select + select#form-select-select + option On + option Off + .field.is-horizontal + .field-label.is-normal + label.label Stream Note Tail SFX + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxStreamNoteTail", value = ((bst2Customization.custom[7] | 0b00001000) == bst2Customization.custom[7]) ? 1 : 0) + .select + select#form-select-select + option On + option Off + .field.is-horizontal + .field-label.is-normal + label.label Inaccurate SFX + .field-body + .control#form-select + input#form-select-input(type = "hidden", name = "sfxFine", value = ((bst2Customization.custom[7] | 0b00010000) == bst2Customization.custom[7]) ? 1 : 0) + .select + select#form-select-select + option On + option Off + .field.is-horizontal + .field-label + .field-body + button.button.is-primary#validatable(type = "submit") + span.icon + i.mdi.mdi-check + span Submit \ No newline at end of file diff --git a/nostalgia@asphyxia/README.md b/nostalgia@asphyxia/README.md index 727d427..bc2ca45 100644 --- a/nostalgia@asphyxia/README.md +++ b/nostalgia@asphyxia/README.md @@ -1,13 +1,32 @@ # Nostalgia -Plugin Version: **v1.0.0** +Plugin Version: **v1.2.0** Supported Versions ------------------- +- ノスタルジア/ First Version (Experiment-Old) +- Forte (Experiment-Old) - Op.2 +About Experiment-Old Support +---------------------------- +A version that marked as **Experiment-Old** is _Not_ Primary supported experiment version. +Since This plugin is mainly focused on Op.2, other versions may not work correctly. + +If you have a problem that move from old version to new version, There's webui for mitigate the issue. + Changelog ========= +1.2.0 (Current) +--------------- + - Nostalgia First version support. + +1.1.0 +----- + - Fix saving issue with brooch, island, and kentei. + - Moved to Base64 encoded data base. + - Forte support. + 1.0.0 ----- Initial Release. diff --git a/nostalgia@asphyxia/data/.gitignore b/nostalgia@asphyxia/data/.gitignore new file mode 100644 index 0000000..a938f45 --- /dev/null +++ b/nostalgia@asphyxia/data/.gitignore @@ -0,0 +1,3 @@ +*.json +*.json +*.xml \ No newline at end of file diff --git a/nostalgia@asphyxia/data/FirstMusic.ts b/nostalgia@asphyxia/data/FirstMusic.ts new file mode 100644 index 0000000..256dcf6 --- /dev/null +++ b/nostalgia@asphyxia/data/FirstMusic.ts @@ -0,0 +1,11 @@ +import { CommonMusicData, readJSONOrXML } from "./ForteMusic"; +import { readB64JSON } from "./helper"; + +export async function processData(): Promise { + if (IO.Exists("data/first_mdb.json.b64")) { + return await readB64JSON("data/first_mdb.json.b64"); + } + const data = await readJSONOrXML("data/first_mdb.json", "data/first_mdb.xml") + // await IO.WriteFile("data/first_mdb.json.b64", Buffer.from(JSON.stringify(data)).toString("base64")) + return data; +} \ No newline at end of file diff --git a/nostalgia@asphyxia/data/ForteMusic.ts b/nostalgia@asphyxia/data/ForteMusic.ts new file mode 100644 index 0000000..b22a806 --- /dev/null +++ b/nostalgia@asphyxia/data/ForteMusic.ts @@ -0,0 +1,70 @@ +import { CommonMusicDataField, readB64JSON, readXML } from "./helper"; + +export async function processData(): Promise { + if (IO.Exists("data/forte_mdb.json.b64")) { + return await readB64JSON("data/forte_mdb.json.b64"); + } + const data = await readJSONOrXML("data/forte_mdb.json", "data/forte_mdb.xml") + return data; +} + +export async function processMdbData(path: string): Promise { + const data = await readXML(path); + const attr = $(data).attr("music_list"); + const mdb = $(data).elements("music_list.music_spec"); + const music: CommonMusicDataField[] = []; + for (const m of mdb) { + music.push(K.ATTR({ index: m.attr().index }, { + basename: K.ITEM("str", m.str("basename")), + title: K.ITEM("str", m.str("title", "title")), + title_kana: K.ITEM("str", m.str("title_kana", "title_kana")), + artist: K.ITEM("str", m.str("artist", "artist")), + artist_kana: K.ITEM("str", m.str("artist_kana", "artist_kana")), + priority: K.ITEM("s8", m.number("priority")), + category_flag: K.ARRAY("s32", m.numbers("category_flag")), + primary_category: K.ITEM("s8", m.number("primary_category")), + level_normal: K.ITEM("s8", m.number("level_normal")), + level_hard: K.ITEM("s8", m.number("level_hard")), + level_extreme: K.ITEM("s8", m.number("level_extreme")), + demo_popular: K.ITEM("bool", m.bool("demo_popular")), + demo_bemani: K.ITEM("bool", m.bool("demo_bemani")), + destination_j: K.ITEM("bool", true), + destination_a: K.ITEM("bool", true), + destination_y: K.ITEM("bool", true), + destination_k: K.ITEM("bool", true), + offline: K.ITEM("bool", m.bool("offline")), + unlock_type: K.ITEM("s8", m.number("unlock_type") == 3 ? 1 : m.number("unlock_type")), + volume_bgm: K.ITEM("s8", m.number("volume_bgm")), + volume_key: K.ITEM("s8", m.number("volume_key")), + start_date: K.ITEM("str", m.str("start_date")), + end_date: K.ITEM("str", "9999-12-31 23:59"), + description: K.ITEM("str", m.str("description", "description")) + })); + } + return K.ATTR({ + release_code: attr.release_code, + revision: attr.revision, + }, { + music_spec: music, + }); +} + +export async function readJSONOrXML(jsonPath: string, xmlPath: string): Promise { + if (!IO.Exists(jsonPath)) { + const data = await processMdbData(xmlPath) + await IO.WriteFile(jsonPath, JSON.stringify(data)) + await IO.WriteFile(jsonPath.replace(".json", ".json.b64"), Buffer.from((JSON.stringify(data))).toString('base64')); + return data + } else { + const json = JSON.parse(await IO.ReadFile(jsonPath, 'utf-8')) + return json + } +} + +export interface CommonMusicData { + "@attr": { + revision: string, + release_code: string + } + music_spec: CommonMusicDataField[] +} \ No newline at end of file diff --git a/nostalgia@asphyxia/data/course.json.b64 b/nostalgia@asphyxia/data/course.json.b64 new file mode 100644 index 0000000..8a2d34c --- /dev/null +++ b/nostalgia@asphyxia/data/course.json.b64 @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/nostalgia@asphyxia/data/course.xml b/nostalgia@asphyxia/data/course.xml deleted file mode 100644 index 4d44eb3..0000000 --- a/nostalgia@asphyxia/data/course.xml +++ /dev/null @@ -1,699 +0,0 @@ - - - - ベーシック10級検定 - 40 - 1000 - 1 - 80000 - - - 140 - 0 - 850000 - - - 225 - 0 - 1725000 - - - 170 - 0 - 2625000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック9級検定 - 39 - 1500 - 1 - 120000 - - - 199 - 0 - 875000 - - - 209 - 0 - 1775000 - - - 212 - 0 - 2700000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック8級検定 - 38 - 2000 - 1 - 200000 - - - 220 - 1 - 900000 - - - 232 - 1 - 1825000 - - - 82 - 0 - 2775000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック7級検定 - 37 - 2500 - 1 - 300000 - - - 186 - 1 - 925000 - - - 141 - 1 - 1875000 - - - 32 - 1 - 2850000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック6級検定 - 36 - 3000 - 1 - 400000 - - - 36 - 1 - 925000 - - - 87 - 1 - 1875000 - - - 242 - 1 - 2850000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック5級検定 - 35 - 3500 - 1 - 450000 - - - 122 - 2 - 925000 - - - 40 - 2 - 1875000 - - - 85 - 2 - 2850000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - ベーシック4級検定 - 34 - 4000 - 1 - 500000 - - - 7 - 2 - 925000 - - - 28 - 2 - 1875000 - - - 49 - 0 - 2850000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - ベーシック3級検定 - 33 - 4500 - 1 - 525000 - - - 8 - 2 - 925000 - - - 29 - 0 - 1875000 - - - 50 - 1 - 2850000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - ベーシック2級検定 - 32 - 5000 - 1 - 540000 - - - 9 - 0 - 925000 - - - 30 - 1 - 1875000 - - - 51 - 2 - 2850000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - ベーシック1級検定 - 31 - 6000 - 1 - 550000 - - - 10 - 1 - 925000 - - - 31 - 2 - 1875000 - - - 52 - 2 - 2850000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - リサイタル10級検定 - 30 - 1000 - 2 - 80000 - - - 7 - 1 - 34000 - - - 238 - 1 - 72000 - - - 227 - 1 - 114000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル9級検定 - 29 - 1500 - 2 - 120000 - - - 19 - 1 - 36000 - - - 220 - 1 - 76000 - - - 214 - 1 - 120000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル8級検定 - 28 - 2000 - 2 - 200000 - - - 8 - 1 - 38000 - - - 63 - 1 - 80000 - - - 86 - 2 - 126000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル7級検定 - 27 - 2500 - 2 - 300000 - - - 72 - 2 - 40000 - - - 71 - 2 - 84000 - - - 70 - 2 - 132000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル6級検定 - 26 - 3000 - 2 - 400000 - - - 105 - 1 - 40000 - - - 101 - 2 - 84000 - - - 186 - 2 - 132000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル5級検定 - 25 - 3500 - 2 - 450000 - - - 26 - 2 - 40000 - - - 160 - 1 - 84000 - - - 133 - 2 - 132000 - - - 0 - - 2019-01-01 10:00 - 9999-01-01 00:00 - - - リサイタル4級検定 - 24 - 4000 - 2 - 500000 - - - 17 - 0 - 40000 - - - 38 - 1 - 84000 - - - 59 - 2 - 132000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - リサイタル3級検定 - 23 - 4500 - 2 - 525000 - - - 18 - 1 - 40000 - - - 39 - 2 - 84000 - - - 60 - 2 - 132000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - リサイタル2級検定 - 22 - 5000 - 2 - 540000 - - - 19 - 2 - 40000 - - - 40 - 2 - 84000 - - - 61 - 0 - 132000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - リサイタル1級検定 - 21 - 6000 - 2 - 550000 - - - 20 - 2 - 40000 - - - 41 - 0 - 84000 - - - 62 - 1 - 132000 - - - 0 - - 2020-01-21 10:00 - 9999-01-01 00:00 - - - KACスペシャル検定(Normal) - 60 - 2000 - 1 - 0 - - - 261 - 0 - 900000 - - - 262 - 0 - 1800000 - - - 263 - 0 - 2750000 - - - 263 - - - 1 - 263 - 2 - - - 2019-02-28 10:00 - 9999-01-01 00:00 - - - KACスペシャル検定(Hard) - 59 - 2000 - 1 - 0 - - - 261 - 1 - 925000 - - - 262 - 1 - 1875000 - - - 263 - 1 - 2850000 - - - 263 - - - 1 - 263 - 2 - - - 2019-02-28 10:00 - 9999-01-01 00:00 - - - KACスペシャル検定(Expert) - 58 - 2000 - 1 - 0 - - - 261 - 2 - 925000 - - - 262 - 2 - 1875000 - - - 263 - 2 - 2850000 - - - 263 - - - 1 - 263 - 2 - - - 2019-02-28 10:00 - 9999-01-01 00:00 - - - KACスペシャル検定(Real) - 57 - 2000 - 1 - 0 - - - 261 - 3 - 925000 - - - 262 - 3 - 1875000 - - - 263 - 3 - 2850000 - - - 263 - - - 1 - 263 - 2 - - - 2019-02-28 10:00 - 9999-01-01 00:00 - - \ No newline at end of file diff --git a/nostalgia@asphyxia/data/first_mdb.json.b64 b/nostalgia@asphyxia/data/first_mdb.json.b64 new file mode 100644 index 0000000..7d47aec --- /dev/null +++ b/nostalgia@asphyxia/data/first_mdb.json.b64 @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/nostalgia@asphyxia/data/forte_mdb.json.b64 b/nostalgia@asphyxia/data/forte_mdb.json.b64 new file mode 100644 index 0000000..b773ca4 --- /dev/null +++ b/nostalgia@asphyxia/data/forte_mdb.json.b64 @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/nostalgia@asphyxia/data/helper.ts b/nostalgia@asphyxia/data/helper.ts new file mode 100644 index 0000000..ac86b9d --- /dev/null +++ b/nostalgia@asphyxia/data/helper.ts @@ -0,0 +1,43 @@ +export interface CommonMusicDataField { + basename: KITEM<"str">; + title: KITEM<"str">; + title_kana: KITEM<"str">; + artist: KITEM<"str">; + artist_kana: KITEM<"str"> + priority: KITEM<"s8">; + category_flag: KARRAY<"s32">; + primary_category: KITEM<"s8">; + level_normal: KITEM<"s8">; + level_hard: KITEM<"s8">; + level_extreme: KITEM<"s8">; + demo_popular: KITEM<"bool">; + demo_bemani: KITEM<"bool"> + destination_j: KITEM<"bool">; + destination_a: KITEM<"bool">; + destination_y: KITEM<"bool">; + destination_k: KITEM<"bool">; + unlock_type: KITEM<"s8">; + offline: KITEM<"bool">; + volume_bgm: KITEM<"s8">; + volume_key: KITEM<"s8">; + start_date: KITEM<"str">; + end_date: KITEM<"str">; + description: KITEM<"str">; +} + +export async function readXML(path: string) { + const xml = await IO.ReadFile(path, 'utf-8'); + const json = U.parseXML(xml, false) + return json +} + +export async function readJSON(path: string) { + const str = await IO.ReadFile(path, 'utf-8'); + const json = JSON.parse(str) + return json +} + +export async function readB64JSON(b64path: string) { + const buff = await IO.ReadFile(b64path, 'utf-8'); + return JSON.parse(Buffer.from(buff, 'base64').toString('utf-8')); +} diff --git a/nostalgia@asphyxia/data/island.json.b64 b/nostalgia@asphyxia/data/island.json.b64 new file mode 100644 index 0000000..316e46f --- /dev/null +++ b/nostalgia@asphyxia/data/island.json.b64 @@ -0,0 +1 @@ +eyJpc2xhbmRfZGF0YV9saXN0Ijp7IkBhdHRyIjp7InJlbGVhc2VfY29kZSI6IjIwMTkxMDAyMDAifSwiaXNsYW5kX2RhdGEiOlt7IkBhdHRyIjp7ImluZGV4IjoiMSJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi44Gy44Go44KK44G844Gj44Gh44Gu5LiW55WMIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE4LTAxLTAxIDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyIn0sIm5hbWUiOnsiQGNvbnRlbnQiOiLjga/jgZjjgb7jgorjga7ooZciLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIxNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMTVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTgtMDEtMDEgMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjMifSwibmFtZSI6eyJAY29udGVudCI6IuaXheeri+OBoeOBrua1tyIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls1MDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOls0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMTVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzM2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjE2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOC0wMS0wMSAwNTowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiNCJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi56CC44Gu5Zu9IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzI1MDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMTddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzU0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls3Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4IjpbeyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE4LTAxLTAxIDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiI1In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLlsI/jgZXjgarlrrYiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbNTAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzEwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMThdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOls0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMTUyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6W3siQGNvbnRlbnQiOls1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTgtMDEtMDEgMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjYifSwibmFtZSI6eyJAY29udGVudCI6IuebruimmuOCgeOBruajriIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOls3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE4LTAxLTAxIDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiI3In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLpoqjjga7kuJgiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbNTAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOls3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjIxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIxMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbMTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzIzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOC0wMS0wMSAwNTowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiOCJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi5rC05pm244Gu6LC3IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzI1MDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlsxM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjIyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIyM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6W3siQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbMTVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTgtMDEtMDEgMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjkifSwibmFtZSI6eyJAY29udGVudCI6IuWwj+OBleOBquWutiIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls1MDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbMTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIyM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjI0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4IjpbeyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbMThdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzIxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTgtMDEtMDEgMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjEwIn0sIm5hbWUiOnsiQGNvbnRlbnQiOiJFYXJseSBTdW1tZXIgSXNsYW5kIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzUwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxODhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzM2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTkxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0wMSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA4LTE1IDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTEifSwibmFtZSI6eyJAY29udGVudCI6Ik1pZC1TdW1tZXIgSXNsYW5kIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzUwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxOTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzM2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTkwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0wOCAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA4LTIyIDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTIifSwibmFtZSI6eyJAY29udGVudCI6IlBvc3QtU3VtbWVyIElzbGFuZCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlsxMDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE4OV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNDhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxOTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzU0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTk0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMTVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlsyM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0xNSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA4LTI5IDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTMifSwibmFtZSI6eyJAY29udGVudCI6IuWun+OCiuOBrumHjC3jgoTjgZXjgYTnlZEtIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzIwMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlsxMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI0NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNDFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzcyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fV19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOlsxN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6eyJAY29udGVudCI6WzI1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTAzLTE0IDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDMtMjggMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIxNCJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi5a6f44KK44Gu6YeMLeOBj+OBoOOCguOBrueVkS0iLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMjAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjQzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI0Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbMjZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDMtMjEgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wNC0wNCAwNTowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjE1In0sIm5hbWUiOnsiQGNvbnRlbnQiOiJLQUPjg6rjgrXjgqTjgr/jg6vpg6jploAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOC0xMS0yMSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTAxLTA3IDE4OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTYifSwibmFtZSI6eyJAY29udGVudCI6IuW/mOOCjOOCieOCjOOBn+W7g+ajhOWgtCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlszMDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4IjpbeyJAY29udGVudCI6WzIxNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMTBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI1MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMTldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlsyN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wMS0xMCAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTcifSwibmFtZSI6eyJAY29udGVudCI6IuOBiuOCguOBoeOCg+OBrueOi+WbvSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls1MDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjUwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzEwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNTFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzUyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjUyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls3Nl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4IjpbeyJAY29udGVudCI6WzIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbMjhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wMS0xMCAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMTgifSwibmFtZSI6eyJAY29udGVudCI6Iuecn+WknOS4reOBrua5lueVlCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls3NTAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4IjpbeyJAY29udGVudCI6WzIxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjI0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzEyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI1M10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6W3siQGNvbnRlbnQiOlsyMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzMwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDEtMTAgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjE5In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLpg7fmhIHjga7pmo7mrrUiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMTAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlszOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMThdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzQxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzM0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzQyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzMxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzQzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzMzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzczXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6Wzc0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6Wzc1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzgxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzgyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6Wzk4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6Wzk5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzEzNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNDhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzUyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTUzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE4MV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxODJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzUyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fV19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOlt7IkBjb250ZW50IjpbMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE4LTEyLTI1IDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyMCJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi5YeN44Gm44Gk44GP5bGx6ISIIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzMwMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE0MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxNDFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzE2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTQyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI0N10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNDhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzU0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjQ5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls3Ml0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMjZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wNC0yNSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA1LTA5IDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMjEifSwibmFtZSI6eyJAY29udGVudCI6IumtheaDkeOBrum7hOmHkeODkeODrOOCuSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls1MDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOls1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzI3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzM2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA3LTI1IDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDgtMDggMDU6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyMiJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi5bm75oOz6YO344KS5b2p44KL6ZqO5q61IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzEwMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOls5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTc4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE3OV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxNzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzQyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fV19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOlsyOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6eyJAY29udGVudCI6WzM5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wMi0wNyAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMjMifSwibmFtZSI6eyJAY29udGVudCI6IumiqOOBjOOBneOCiOOBkOmajuautSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlsyMDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6Wzg3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE3MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxNzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzQwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTcyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMjldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOnsiQGNvbnRlbnQiOls0MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDItMDcgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjI0In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLnp4vpm6rjgYzoiJ7jgYbpmo7mrrUiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMjAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzEzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTMxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE0N10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsxNDhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzQyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTQ5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzEzMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzMwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNDFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTAyLTA3IDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyNSJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi5YWJ44GM6ZmN44KK5rOo44GQ6ZqO5q61IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzMwMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbNzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzMyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMTA1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzE2MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzMxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNDJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzIyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTAyLTA3IDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyNiJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi44Ki44OL44OQ44O844K144Oq44O844Ki44Kk44Op44Oz44OJIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzUwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzQ4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjgwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI3OV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNjldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzcyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fV19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOlszM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6eyJAY29udGVudCI6WzQzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wMy0yMSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMjcifSwibmFtZSI6eyJAY29udGVudCI6IuWMluefs+OBruegpiIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlszNTAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4IjpbeyJAY29udGVudCI6WzIxNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjIwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImdldF9tdXNpY19pbmRleF9saXN0Ijp7ImNvbnRhaW5lciI6eyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiIxIn0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzQ1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzM0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNDRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDQtMTEgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjI4In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLpm7Ljga7jgqjjgqLjg53jg7zjg4giLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOls1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbNzAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI2NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNjZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6Wzc2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fV19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOls0NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNDZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzMyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJvZmZsaW5lIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInN0YXJ0X2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA0LTExIDEwOjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJlbmRfZGF0ZSI6eyJAY29udGVudCI6Ijk5OTktMTItMzEgMjM6NTkiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX19LHsiQGF0dHIiOnsiaW5kZXgiOiIyOSJ9LCJuYW1lIjp7IkBjb250ZW50Ijoi6Kmm57e044Gu5rS754Gr5bGxIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6Wzk1MDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlsxMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjY2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxNV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyODVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6Wzg0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjg2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzM2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNDddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDUtMjMgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjMwIn0sIm5hbWUiOnsiQGNvbnRlbnQiOiLnmb3mmLzlpKLjga7msLTlubPnt5oiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbMzAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyODddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzU0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjg0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls3M10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4Ijp7IkBjb250ZW50IjpbMzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbNDhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzQ5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wNy0yNSAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiIyMDE5LTA4LTA4IDA1OjAwIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMzEifSwibmFtZSI6eyJAY29udGVudCI6IumbqOOBruihlyIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls3NTAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4IjpbeyJAY29udGVudCI6WzIxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjI0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzE1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyOTFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzU0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjkyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxMjRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6W3siQGNvbnRlbnQiOlszOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzUwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls1MV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzIxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDctMTEgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiOTk5OS0xMi0zMSAyMzo1OSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjMyIn0sIm5hbWUiOnsiQGNvbnRlbnQiOiJLZXlib2FyZCBNeXRob2xvZ3kgSXNsYW5kIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzIwMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInNlY3Rpb24iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJ0ZWFtIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicG9zaXRpb24iOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOlt7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjg4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlszNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI4OV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbOTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzQwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzhdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzEyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyN10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDgtMjIgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOS0wNSAwNTowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjMzIn0sIm5hbWUiOnsiQGNvbnRlbnQiOiJHVU1JIDEwdGggQW5uaXZlcnNhcnkgSXNsYW5kIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJyb3V0ZV90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiY29zdCI6eyJAY29udGVudCI6WzUwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImVudHJ5X2NvbmRfbXVzaWNfaW5kZXhfbGlzdCI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6W3sibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyOTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzMwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSx7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjk0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0seyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI5NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19XX19LCJ1c2VkX3ByYWN0aWNlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2NvbmNvdXJzIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfbGVzc29uX2FuZF90ZXN0Ijp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfcmVjaXRhbF9wcm9ncmFtX2luZGV4X2xpc3QiOnsicHJvZ3JhbV9pbmRleCI6eyJAY29udGVudCI6WzQxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4Ijp7IkBjb250ZW50IjpbNTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJob3dfdG9fZWFybl9wb2ludF9pbmRleF9saXN0Ijp7Imhvd190b19lYXJuX3BvaW50X2luZGV4IjpbeyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzE2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzM1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sIm9mZmxpbmUiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwic3RhcnRfZGF0ZSI6eyJAY29udGVudCI6IjIwMTktMDYtMjYgMTA6MDAiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sImVuZF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wNy0xMSAwNTowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fX0seyJAYXR0ciI6eyJpbmRleCI6IjM0In0sIm5hbWUiOnsiQGNvbnRlbnQiOiLnnKDjgonjgarjgYTlt6XloLQiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sInJvdXRlX3R5cGUiOnsiQGNvbnRlbnQiOls0XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJjb3N0Ijp7IkBjb250ZW50IjpbNjUwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlsyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzEyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzE3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMTZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjpbeyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzI5Nl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LHsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyOTddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzEyNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX1dfX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4IjpbeyJAY29udGVudCI6WzQyXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls0NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJ1c2VkX3JlY2l0YWxfaGFsbF9pbmRleF9saXN0Ijp7ImhhbGxfaW5kZXgiOlt7IkBjb250ZW50IjpbNTRdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzU3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sImhvd190b19lYXJuX3BvaW50X2luZGV4X2xpc3QiOnsiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXgiOlt7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbOF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0wOCAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMzUifSwibmFtZSI6eyJAY29udGVudCI6IuacgOaenOOBpuOBrueglOeptuaJgCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls1MDAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4IjpbeyJAY29udGVudCI6WzI1M10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjg2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsyOTJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI5N10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fV19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOnsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiMSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzE4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyNjddLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzEzMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOlt7IkBjb250ZW50IjpbNDNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzQ2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19XX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6W3siQGNvbnRlbnQiOls1NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNThdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxNF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMjJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0yMiAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMzYifSwibmFtZSI6eyJAY29udGVudCI6IuOBr+OBmOOBvuOCiuOBruWgtOaJgCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOls0NTAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJzZWN0aW9uIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwidGVhbSI6eyJAY29udGVudCI6WzNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInBvc2l0aW9uIjp7IkBjb250ZW50IjpbNl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZW50cnlfY29uZF9tdXNpY19pbmRleF9saXN0Ijp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjY3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiZ2V0X211c2ljX2luZGV4X2xpc3QiOnsiY29udGFpbmVyIjp7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsxOV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjEzXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls1MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX19fSwidXNlZF9wcmFjdGljZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWwiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9jb25jb3VycyI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX2xlc3Nvbl9hbmRfdGVzdCI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJ1c2VkX3JlY2l0YWxfcHJvZ3JhbV9pbmRleF9saXN0Ijp7InByb2dyYW1faW5kZXgiOnsiQGNvbnRlbnQiOls0NF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX0sInVzZWRfcmVjaXRhbF9oYWxsX2luZGV4X2xpc3QiOnsiaGFsbF9pbmRleCI6eyJAY29udGVudCI6WzU2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNDJdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOC0yMiAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fSx7IkBhdHRyIjp7ImluZGV4IjoiMzcifSwibmFtZSI6eyJAY29udGVudCI6IuiomOaGtuOBrue1guedgOmnhSIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwicm91dGVfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImNvc3QiOnsiQGNvbnRlbnQiOlsxMDAwMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwic2VjdGlvbiI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInRlYW0iOnsiQGNvbnRlbnQiOlszXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwb3NpdGlvbiI6eyJAY29udGVudCI6WzExXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJlbnRyeV9jb25kX211c2ljX2luZGV4X2xpc3QiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyMTNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19LCJnZXRfbXVzaWNfaW5kZXhfbGlzdCI6eyJjb250YWluZXIiOlt7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjEifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlsyMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMjk4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOlsxMDBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fSx7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjIifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlsyOTldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fSx7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjMifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlszMDFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6Wzc2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX0seyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiI0In0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMzAwXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls3Nl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX19LHsiQGF0dHIiOnsiY29udGFpbmVyX25vIjoiNSJ9LCJjb250YWluZXJfdHlwZSI6eyJAY29udGVudCI6WzFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX251bSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sInByZWNpb3VzX2l0ZW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9wYWNrYWdlIjp7IkBjb250ZW50IjoiX2xhYmVsIiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19LCJtdXNpYyI6eyJtdXNpY19pbmRleCI6eyJAY29udGVudCI6WzMwMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwiZ2V0X3BvaW50Ijp7IkBjb250ZW50IjpbNzZdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX19fSx7IkBhdHRyIjp7ImNvbnRhaW5lcl9ubyI6IjYifSwiY29udGFpbmVyX3R5cGUiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJtb3ZpZV9udW0iOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJwcmVjaW91c19pdGVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfcGFja2FnZSI6eyJAY29udGVudCI6Il9sYWJlbCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwibXVzaWMiOnsibXVzaWNfaW5kZXgiOnsiQGNvbnRlbnQiOlszMDNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sImdldF9wb2ludCI6eyJAY29udGVudCI6Wzc2XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19fX0seyJAYXR0ciI6eyJjb250YWluZXJfbm8iOiI3In0sImNvbnRhaW5lcl90eXBlIjp7IkBjb250ZW50IjpbM10sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwibW92aWVfbnVtIjp7IkBjb250ZW50IjpbMF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSwicHJlY2lvdXNfaXRlbSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0sIm1vdmllX3BhY2thZ2UiOnsiQGNvbnRlbnQiOiJfbGFiZWwiLCJAYXR0ciI6eyJfX3R5cGUiOiJzdHIifX0sIm11c2ljIjp7Im11c2ljX2luZGV4Ijp7IkBjb250ZW50IjpbMzA1XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LCJnZXRfcG9pbnQiOnsiQGNvbnRlbnQiOls4NV0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fX19XX0sInVzZWRfcHJhY3RpY2UiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsIjp7IkBjb250ZW50IjpbMV0sIkBhdHRyIjp7Il9fdHlwZSI6ImJvb2wifX0sInVzZWRfY29uY291cnMiOnsiQGNvbnRlbnQiOlswXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9sZXNzb25fYW5kX3Rlc3QiOnsiQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiYm9vbCJ9fSwidXNlZF9yZWNpdGFsX3Byb2dyYW1faW5kZXhfbGlzdCI6eyJwcm9ncmFtX2luZGV4IjpbeyJAY29udGVudCI6WzQ3XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls0OF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNDldLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwidXNlZF9yZWNpdGFsX2hhbGxfaW5kZXhfbGlzdCI6eyJoYWxsX2luZGV4IjpbeyJAY29udGVudCI6WzU5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls2MF0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNjFdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwiaG93X3RvX2Vhcm5fcG9pbnRfaW5kZXhfbGlzdCI6eyJob3dfdG9fZWFybl9wb2ludF9pbmRleCI6W3siQGNvbnRlbnQiOlsxXSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOls4XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlsxMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbNDNdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX0seyJAY29udGVudCI6WzI5XSwiQGF0dHIiOnsiX190eXBlIjoiczMyIn19LHsiQGNvbnRlbnQiOlszMl0sIkBhdHRyIjp7Il9fdHlwZSI6InMzMiJ9fSx7IkBjb250ZW50IjpbMzVdLCJAYXR0ciI6eyJfX3R5cGUiOiJzMzIifX1dfSwib2ZmbGluZSI6eyJAY29udGVudCI6WzBdLCJAYXR0ciI6eyJfX3R5cGUiOiJib29sIn19LCJzdGFydF9kYXRlIjp7IkBjb250ZW50IjoiMjAxOS0wOS0yNiAxMDowMCIsIkBhdHRyIjp7Il9fdHlwZSI6InN0ciJ9fSwiZW5kX2RhdGUiOnsiQGNvbnRlbnQiOiI5OTk5LTEyLTMxIDIzOjU5IiwiQGF0dHIiOnsiX190eXBlIjoic3RyIn19fV19fQ== \ No newline at end of file diff --git a/nostalgia@asphyxia/data/island.xml b/nostalgia@asphyxia/data/island.xml deleted file mode 100644 index b4c558b..0000000 --- a/nostalgia@asphyxia/data/island.xml +++ /dev/null @@ -1,1996 +0,0 @@ - - - - ひとりぼっちの世界 - 1 - 0 -
1
- 1 - 0 - - 0 - - - - 1 - 1 - 0 - _label - - 0 - 0 - - - - 1 - 1 - 0 - 1 - - 0 - - - 0 - - - 0 - - 1 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - はじまりの街 - 2 - 0 -
1
- 1 - 1 - - 0 - - - - 1 - 2 - 1 - _label - - 214 - 15 - - - - 1 - 1 - 0 - 1 - - 1 - - - 1 - 2 - - - 3 - 4 - 5 - 32 - 35 - - 1 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 旅立ちの海 - 2 - 500 -
1
- 1 - 4 - - 214 - - - - 1 - 3 - 2 - _label - - 215 - 36 - - - 216 - 54 - - - - 1 - 1 - 0 - 1 - - 2 - - - 3 - 4 - - - 2 - 5 - 16 - 15 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 砂の国 - 2 - 2500 -
1
- 1 - 9 - - 216 - - - - 1 - 4 - 3 - _label - - 217 - 54 - - - 218 - 72 - - - - 1 - 1 - 0 - 1 - - 3 - 4 - - - 5 - 6 - 7 - - - 1 - 6 - 7 - 15 - 14 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 小さな家 - 2 - 5000 -
1
- 1 - 10 - - 218 - - - - 1 - 5 - 4 - _label - - 219 - 152 - - - - 1 - 1 - 0 - 1 - - 5 - 6 - - - 8 - 9 - 10 - - - 1 - 7 - 8 - 14 - 13 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 目覚めの森 - 3 - 0 -
1
- 1 - 3 - - 0 - - - - 1 - 6 - 5 - _label - - 220 - 15 - - - - 1 - 1 - 0 - 1 - - 7 - - - 11 - 12 - - - 3 - 4 - 5 - 32 - 35 - - 1 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 風の丘 - 3 - 500 -
1
- 1 - 8 - - 220 - - - - 1 - 7 - 6 - _label - - 221 - 36 - - - 211 - 54 - - - - 1 - 1 - 0 - 1 - - 8 - - - 13 - 14 - - - 2 - 5 - 17 - 23 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 水晶の谷 - 3 - 2500 -
1
- 1 - 13 - - 211 - - - - 1 - 8 - 7 - _label - - 222 - 54 - - - 223 - 72 - - - - 1 - 1 - 0 - 1 - - 9 - 10 - - - 15 - 16 - 17 - - - 1 - 6 - 7 - 19 - 25 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - 小さな家 - 3 - 5000 -
1
- 1 - 12 - - 223 - - - - 1 - 9 - 8 - _label - - 224 - 152 - - - - 1 - 1 - 0 - 1 - - 11 - 12 - - - 18 - 19 - 20 - - - 1 - 7 - 8 - 21 - 26 - 32 - 35 - - 0 - 2018-01-01 05:00 - 9999-12-31 23:59 - - - Early Summer Island - 1 - 500 -
2
- 1 - 1 - - 0 - - - - 3 - 0 - 0 - _label - - 188 - 36 - - - 191 - 54 - - - - 1 - 1 - 0 - 1 - - 13 - - - 21 - - - 2 - 5 - 24 - 18 - 32 - 35 - - 0 - 2019-08-01 10:00 - 2019-08-15 05:00 - - - Mid-Summer Island - 1 - 500 -
2
- 1 - 2 - - 0 - - - - 3 - 0 - 0 - _label - - 192 - 36 - - - 190 - 54 - - - - 1 - 1 - 0 - 1 - - 14 - - - 22 - - - 2 - 5 - 24 - 18 - 32 - 35 - - 0 - 2019-08-08 10:00 - 2019-08-22 05:00 - - - Post-Summer Island - 1 - 1000 -
2
- 1 - 3 - - 0 - - - - 3 - 0 - 0 - _label - - 189 - 48 - - - 193 - 54 - - - 194 - 24 - - - - 1 - 1 - 0 - 1 - - 15 - - - 23 - - - 1 - 6 - 7 - 25 - 19 - 32 - 35 - - 0 - 2019-08-15 10:00 - 2019-08-29 05:00 - - - 実りの里-やさい畑- - 1 - 2000 -
2
- 1 - 10 - - 0 - - - - 3 - 0 - 0 - _label - - 244 - 54 - - - 241 - 72 - - - - 1 - 1 - 0 - 1 - - 17 - - - 25 - - - 1 - 8 - 9 - 21 - 26 - 32 - 35 - - 0 - 2019-03-14 10:00 - 2019-03-28 05:00 - - - 実りの里-くだもの畑- - 1 - 2000 -
2
- 1 - 11 - - 0 - - - - 3 - 0 - 0 - _label - - 243 - 54 - - - 242 - 72 - - - - 1 - 1 - 0 - 1 - - 18 - - - 26 - - - 1 - 8 - 9 - 15 - 14 - 32 - 35 - - 0 - 2019-03-21 10:00 - 2019-04-04 05:00 - - - KACリサイタル部門 - 1 - 0 -
2
- 1 - 7 - - 0 - - - - 3 - 0 - 0 - _label - - 0 - 0 - - - - 1 - 1 - 0 - 1 - - 16 - - - 24 - - - 0 - - 0 - 2018-11-21 10:00 - 2019-01-07 18:00 - - - 忘れられた廃棄場 - 4 - 3000 -
1
- 1 - 2 - - 214 - 220 - - - - 1 - 10 - 9 - _label - - 250 - 30 - - - - 1 - 1 - 0 - 1 - - 19 - - - 27 - - - 1 - 4 - 5 - 25 - 26 - 32 - 35 - - 0 - 2019-01-10 10:00 - 9999-12-31 23:59 - - - おもちゃの王国 - 4 - 5000 -
1
- 1 - 6 - - 250 - - - - 1 - 11 - 10 - _label - - 251 - 52 - - - 252 - 76 - - - - 1 - 1 - 0 - 1 - - 20 - 21 - - - 28 - 29 - - - 1 - 7 - 8 - 21 - 26 - 32 - 35 - - 0 - 2019-01-10 10:00 - 9999-12-31 23:59 - - - 真夜中の湖畔 - 3 - 7500 -
1
- 2 - 3 - - 219 - 224 - 252 - - - - 1 - 12 - 11 - _label - - 254 - 124 - - - 253 - 54 - - - - 1 - 1 - 0 - 1 - - 22 - 23 - - - 30 - 31 - - - 1 - 8 - 9 - 14 - 13 - 32 - 35 - - 0 - 2019-01-10 10:00 - 9999-12-31 23:59 - - - 郷愁の階段 - 1 - 1000 -
2
- 1 - 6 - - 0 - - - - 3 - 1 - 0 - _label - - 19 - 12 - - - 38 - 18 - - - 3 - 24 - - - 20 - 24 - - - 41 - 30 - - - 34 - 30 - - - 42 - 36 - - - 31 - 36 - - - 35 - 36 - - - 43 - 36 - - - 33 - 42 - - - 73 - 42 - - - 74 - 48 - - - 75 - 48 - - - 81 - 48 - - - 82 - 48 - - - 98 - 48 - - - 99 - 48 - - - 134 - 48 - - - 135 - 52 - - - 153 - 52 - - - 181 - 52 - - - 182 - 52 - - - - 1 - 1 - 0 - 1 - - 24 - 25 - - - 32 - 33 - 34 - - - 1 - 7 - 16 - 20 - 25 - 29 - 33 - 35 - - 0 - 2018-12-25 10:00 - 9999-12-31 23:59 - - - 凍てつく山脈 - 1 - 3000 -
2
- 1 - 12 - - 0 - - - - 3 - 0 - 0 - _label - - 140 - 16 - - - 141 - 16 - - - 142 - 16 - - - 247 - 24 - - - 248 - 54 - - - 249 - 72 - - - - 1 - 1 - 0 - 1 - - 26 - - - 35 - - - 2 - 6 - 25 - 19 - 32 - 35 - - 0 - 2019-04-25 10:00 - 2019-05-09 05:00 - - - 魅惑の黄金パレス - 1 - 500 -
2
- 1 - 5 - - 0 - - - - 3 - 0 - 0 - _label - - 0 - 0 - - - - 1 - 1 - 0 - 1 - - 27 - - - 36 - 37 - 38 - - - 0 - - 0 - 2019-07-25 10:00 - 2019-08-08 05:00 - - - 幻想郷を彩る階段 - 1 - 1000 -
2
- 1 - 9 - - 0 - - - - 3 - 0 - 0 - _label - - 178 - 20 - - - 179 - 30 - - - 177 - 42 - - - - 1 - 1 - 0 - 1 - - 28 - - - 39 - - - 1 - 5 - 6 - 16 - 15 - 29 - 33 - 35 - - 0 - 2019-02-07 10:00 - 9999-12-31 23:59 - - - 風がそよぐ階段 - 1 - 2000 -
2
- 1 - 4 - - 0 - - - - 3 - 0 - 0 - _label - - 87 - 24 - - - 170 - 32 - - - 171 - 40 - - - 172 - 54 - - - - 1 - 1 - 0 - 1 - - 29 - - - 40 - - - 1 - 5 - 6 - 24 - 25 - 29 - 33 - 35 - - 0 - 2019-02-07 10:00 - 9999-12-31 23:59 - - - 秋雪が舞う階段 - 1 - 2000 -
2
- 1 - 13 - - 0 - - - - 3 - 0 - 0 - _label - - 131 - 24 - - - 147 - 32 - - - 148 - 42 - - - 149 - 50 - - - 130 - 64 - - - - 1 - 1 - 0 - 1 - - 30 - - - 41 - - - 1 - 5 - 6 - 18 - 19 - 29 - 33 - 35 - - 0 - 2019-02-07 10:00 - 9999-12-31 23:59 - - - 光が降り注ぐ階段 - 1 - 3000 -
2
- 1 - 8 - - 0 - - - - 3 - 0 - 0 - _label - - 76 - 32 - - - 105 - 48 - - - 160 - 64 - - - - 1 - 1 - 0 - 1 - - 31 - - - 42 - - - 1 - 7 - 8 - 22 - 26 - 29 - 33 - 35 - - 0 - 2019-02-07 10:00 - 9999-12-31 23:59 - - - アニバーサリーアイランド - 1 - 500 -
2
- 1 - 7 - - 0 - - - - 3 - 0 - 0 - _label - - 270 - 48 - - - 280 - 48 - - - 279 - 54 - - - 269 - 72 - - - - 1 - 1 - 0 - 1 - - 33 - - - 43 - - - 1 - 5 - 24 - 19 - 16 - 32 - 35 - - 0 - 2019-03-21 10:00 - 9999-12-31 23:59 - - - 化石の砦 - 5 - 3500 -
1
- 2 - 6 - - 214 - 220 - - - - 1 - 13 - 12 - _label - - 264 - 45 - - - - 1 - 1 - 0 - 1 - - 34 - - - 44 - - - 1 - 4 - 5 - 25 - 26 - 32 - 35 - - 0 - 2019-04-11 10:00 - 9999-12-31 23:59 - - - 雲のエアポート - 5 - 7000 -
1
- 2 - 11 - - 264 - - - - 1 - 14 - 13 - _label - - 265 - 52 - - - 266 - 76 - - - - 1 - 1 - 0 - 1 - - 35 - - - 45 - 46 - - - 1 - 7 - 8 - 21 - 26 - 32 - 35 - - 0 - 2019-04-11 10:00 - 9999-12-31 23:59 - - - 試練の活火山 - 5 - 9500 -
1
- 2 - 10 - - 266 - - - - 1 - 15 - 14 - _label - - 285 - 84 - - - 286 - 100 - - - - 1 - 1 - 0 - 1 - - 36 - - - 47 - - - 1 - 8 - 9 - 14 - 26 - 32 - 35 - - 0 - 2019-05-23 10:00 - 9999-12-31 23:59 - - - 白昼夢の水平線 - 1 - 3000 -
2
- 2 - 2 - - 0 - - - - 3 - 0 - 0 - _label - - 287 - 54 - - - 284 - 73 - - - - 1 - 1 - 0 - 1 - - 37 - - - 48 - 49 - - - 1 - 7 - 9 - 21 - 14 - 32 - 35 - - 0 - 2019-07-25 10:00 - 2019-08-08 05:00 - - - 雨の街 - 2 - 7500 -
1
- 2 - 1 - - 219 - 224 - 252 - - - - 1 - 16 - 15 - _label - - 291 - 54 - - - 292 - 124 - - - - 1 - 1 - 0 - 1 - - 38 - 39 - - - 50 - 51 - - - 1 - 7 - 9 - 21 - 26 - 32 - 35 - - 0 - 2019-07-11 10:00 - 9999-12-31 23:59 - - - Keyboard Mythology Island - 1 - 2000 -
2
- 2 - 1 - - 0 - - - - 3 - 0 - 0 - _label - - 288 - 36 - - - 289 - 92 - - - - 1 - 1 - 0 - 1 - - 40 - - - 52 - - - 1 - 7 - 8 - 12 - 27 - 32 - 35 - - 0 - 2019-08-22 10:00 - 2019-09-05 05:00 - - - GUMI 10th Anniversary Island - 1 - 500 -
2
- 2 - 3 - - 0 - - - - 3 - 0 - 0 - _label - - 293 - 30 - - - 294 - 50 - - - 295 - 76 - - - - 1 - 1 - 0 - 1 - - 41 - - - 53 - - - 1 - 6 - 7 - 16 - 29 - 32 - 35 - - 0 - 2019-06-26 10:00 - 2019-07-11 05:00 - - - 眠らない工場 - 4 - 6500 -
1
- 2 - 12 - - 252 - - - - 1 - 17 - 16 - _label - - 296 - 54 - - - 297 - 124 - - - - 1 - 1 - 0 - 1 - - 42 - 45 - - - 54 - 57 - - - 1 - 8 - 9 - 12 - 27 - 32 - 35 - - 0 - 2019-08-08 10:00 - 9999-12-31 23:59 - - - 最果ての研究所 - 1 - 5000 -
1
- 3 - 2 - - 253 - 286 - 292 - 297 - - - - 1 - 18 - 0 - _label - - 267 - 130 - - - - 1 - 1 - 0 - 1 - - 43 - 46 - - - 55 - 58 - - - 1 - 6 - 14 - 22 - 26 - 32 - 35 - - 0 - 2019-08-22 10:00 - 9999-12-31 23:59 - - - はじまりの場所 - 1 - 4500 -
1
- 3 - 6 - - 267 - - - - 1 - 19 - 0 - _label - - 213 - 50 - - - - 1 - 1 - 0 - 1 - - 44 - - - 56 - - - 1 - 7 - 13 - 42 - 26 - 32 - 35 - - 0 - 2019-08-22 10:00 - 9999-12-31 23:59 - - - 記憶の終着駅 - 1 - 10000 -
1
- 3 - 11 - - 213 - - - - 1 - 20 - 0 - _label - - 298 - 100 - - - - 1 - 0 - 0 - _label - - 299 - 0 - - - - 1 - 0 - 0 - _label - - 301 - 76 - - - - 1 - 0 - 0 - _label - - 300 - 76 - - - - 1 - 0 - 0 - _label - - 302 - 76 - - - - 1 - 0 - 0 - _label - - 303 - 76 - - - - 3 - 0 - 0 - _label - - 305 - 85 - - - - 1 - 1 - 0 - 1 - - 47 - 48 - 49 - - - 59 - 60 - 61 - - - 1 - 8 - 12 - 43 - 29 - 32 - 35 - - 0 - 2019-09-26 10:00 - 9999-12-31 23:59 - - \ No newline at end of file diff --git a/nostalgia@asphyxia/handler/common.ts b/nostalgia@asphyxia/handler/common.ts index ad45e96..472e81d 100644 --- a/nostalgia@asphyxia/handler/common.ts +++ b/nostalgia@asphyxia/handler/common.ts @@ -1,4 +1,8 @@ -import * as path from "path"; + +import { processData as firstData } from "../data/FirstMusic"; +import { processData as forteData } from "../data/ForteMusic"; +import { readB64JSON } from "../data/helper"; +import { NosVersionHelper } from "../utils"; export const permitted_list = { flag: [ @@ -9,10 +13,22 @@ export const permitted_list = { ], }; +export const forte_permitted_list = { + flag: [ + K.ARRAY('s32', Array(32).fill(-1), { sheet_type: '0' }), + K.ARRAY('s32', Array(32).fill(-1), { sheet_type: '1' }), + K.ARRAY('s32', Array(32).fill(-1), { sheet_type: '2' }), + ], +} + async function ReadData(filename: string) { - const xml = await IO.ReadFile(`data/${filename}.xml`, { encoding: 'utf-8'}); + if (!IO.Exists(`data/${filename}.json.b64`)) { + const xml = await IO.ReadFile(`data/${filename}.xml`, 'utf-8'); const json = U.parseXML(xml, false) + // await IO.WriteFile(`data/${filename}.json.b64`, Buffer.from(JSON.stringify(json)).toString('base64')); return json + } + return readB64JSON(`data/${filename}.json.b64`) } async function processIslandData() { @@ -56,7 +72,7 @@ async function processCourseData() { return { course_data: courseData }; } -export const get_common_info = async (req, data, send) => { +export const get_common_info = async (info, data, send) => { send.object({ permitted_list, olupdate: { @@ -65,10 +81,12 @@ export const get_common_info = async (req, data, send) => { }); }; -export const get_music_info: EPR = async (req, data, send) => { +export const get_music_info: EPR = async (info, data, send) => { + const version = new NosVersionHelper(info) + const music_spec: any = []; for (let i = 1; i < 400; ++i) { - music_spec.push(K.ATTR({ index: `${i}`}, { + music_spec.push(K.ATTR({ index: `${i}` }, { jk_jpn: K.ITEM('bool', 1), jk_asia: K.ITEM('bool', 1), jk_kor: K.ITEM('bool', 1), @@ -83,18 +101,27 @@ export const get_music_info: EPR = async (req, data, send) => { })); } - send.object({ - permitted_list, + const music_list = async () => version.version === 'Forte' ? await forteData() : await firstData() - island_data_list: await processIslandData(), - course_data_list: await processCourseData(), + const versionObject = version.isFirstOrForte() + ? { + permitted_list: forte_permitted_list, + music_list: await music_list() + } + : { + permitted_list, + island_data_list: await processIslandData(), + course_data_list: await processCourseData(), - overwrite_music_list: K.ATTR({ + overwrite_music_list: K.ATTR({ revision: '16706', release_code: '2019100200', }, { - music_spec: music_spec, - }), + music_spec: music_spec, + }), + }; + send.object({ + ...versionObject, gamedata_flag_list: { event: { diff --git a/nostalgia@asphyxia/handler/player.ts b/nostalgia@asphyxia/handler/player.ts index fa4c775..fe2dd58 100644 --- a/nostalgia@asphyxia/handler/player.ts +++ b/nostalgia@asphyxia/handler/player.ts @@ -1,11 +1,7 @@ -// import { EAHandler } from '../../util/EAHandler'; -// import { get, _.isArray } from 'lodash'; -// import { Logger } from '../../util/Logger'; import { Profile } from '../models/profile'; import { Scores } from '../models/scores'; -import { permitted_list } from './common'; -// import { getValue, getArray, getAttr, getStr, getBigInt } from '../../util/Helper'; - +import { NosVersionHelper } from '../utils'; +import { permitted_list, forte_permitted_list } from './common'; // export const event_list = { // event: { @@ -18,9 +14,10 @@ import { permitted_list } from './common'; // }, // }; -const getEventInfo = () => { +const getEventInfo = (version: NosVersionHelper) => { const event: any[] = []; - for (let i = 1; i <= 17; ++i) { + const event_num = version.getEventMaxIndex() + for (let i = 1; i <= event_num; ++i) { event.push({ type: K.ITEM('s32', 4), index: K.ITEM('s32', i), @@ -34,8 +31,9 @@ const getEventInfo = () => { return event; }; -const getPlayerData = async (refid: string, name?: string) => { +const getPlayerData = async (refid: string, info: EamuseInfo, name?: string) => { const p = await readProfile(refid); + const version = new NosVersionHelper(info) if (name && name.length > 0) { p.name = name; @@ -45,7 +43,7 @@ const getPlayerData = async (refid: string, name?: string) => { const param: any[] = []; for (const t in p.params) { const para = p.params[t]; - param.push(K.ATTR({type: t}, { + param.push(K.ATTR({ type: t }, { count: K.ITEM('s32', para.length), params_array: K.ARRAY('s32', para), })); @@ -53,6 +51,7 @@ const getPlayerData = async (refid: string, name?: string) => { const brooch: any[] = []; for (const b in p.brooches) { + if (parseInt(b, 10) > version.getBroochMaxIndex()) continue; const bData = p.brooches[b]; brooch.push(K.ATTR({ index: b }, { watch_count: K.ITEM('s32', bData.watch), @@ -64,6 +63,7 @@ const getPlayerData = async (refid: string, name?: string) => { // Unlock brooches for (let i = 101; i <= 124; ++i) { + if (i > version.getBroochMaxIndex()) continue; brooch.push(K.ATTR({ index: `${i}` }, { 'watch_count': K.ITEM('s32', 0), 'level': K.ITEM('s8', 1), @@ -72,6 +72,20 @@ const getPlayerData = async (refid: string, name?: string) => { })); } + // Forte + const stairs: any[] = []; + for (const s in (p.cat_stairs || defaultProfile.cat_stairs)) { + const stair = (p.cat_stairs || defaultProfile.cat_stairs)[s]; + + stairs.push(K.ATTR({ index: s }, { + total_steps: K.ITEM("s32", stair.total), + chapter_index: K.ITEM("s32", stair.index), + chapter_steps: K.ITEM("s32", stair.steps), + chapter_goal: K.ITEM("s32", stair.goal) + })); + } + + // >= Op2 const kentei_record: any[] = []; for (const k in p.kentei) { const kentei = p.kentei[k]; @@ -86,6 +100,7 @@ const getPlayerData = async (refid: string, name?: string) => { }); } + // >= Op2 const island_progress: any[] = []; for (const i in p.islands) { const island = p.islands[i]; @@ -119,40 +134,50 @@ const getPlayerData = async (refid: string, name?: string) => { })); } + const correct_permitted_list = !version.isFirstOrForte() ? permitted_list : forte_permitted_list + const music_list = [ + K.ARRAY('s32', p.musicList.type_0, { sheet_type: '0' }), + K.ARRAY('s32', p.musicList.type_1, { sheet_type: '1' }), + K.ARRAY('s32', p.musicList.type_2, { sheet_type: '2' }), + K.ARRAY('s32', p.musicList.type_3, { sheet_type: '3' }), + ]; + const music_list2 = [ + K.ARRAY('s32', p.musicList2.type_0, { sheet_type: '0' }), + K.ARRAY('s32', p.musicList2.type_1, { sheet_type: '1' }), + K.ARRAY('s32', p.musicList2.type_2, { sheet_type: '2' }), + K.ARRAY('s32', p.musicList2.type_3, { sheet_type: '3' }), + ]; + + if(version.isFirstOrForte()) { + music_list.pop(); + music_list2.pop(); + } + return { name: K.ITEM('str', p.name), play_count: K.ITEM('s32', p.playCount), today_play_count: K.ITEM('s32', p.todayPlayCount), - permitted_list, - event_info_list: { event: getEventInfo() }, + permitted_list: correct_permitted_list, + event_info_list: { event: getEventInfo(version) }, // Op2 + event_control_list: { event: getEventInfo(version) }, // Forte music_list: { - flag: [ - K.ARRAY('s32', p.musicList.type_0, { sheet_type: '0' }), - K.ARRAY('s32', p.musicList.type_1, { sheet_type: '1' }), - K.ARRAY('s32', p.musicList.type_2, { sheet_type: '2' }), - K.ARRAY('s32', p.musicList.type_3, { sheet_type: '3' }), - ], + flag: music_list, }, free_for_play_music_list: { - flag: [ - K.ARRAY('s32', p.musicList2.type_0, { sheet_type: '0' }), - K.ARRAY('s32', p.musicList2.type_1, { sheet_type: '1' }), - K.ARRAY('s32', p.musicList2.type_2, { sheet_type: '2' }), - K.ARRAY('s32', p.musicList2.type_3, { sheet_type: '3' }), - ], + flag: music_list2, }, last: { - music_index: K.ITEM('s32', p.music), - sheet_type: K.ITEM('s8', p.sheet), - brooch_index: K.ITEM('s32', p.brooch), + music_index: K.ITEM('s32', version.numericHandler('music_index', p.music, 0)), + sheet_type: K.ITEM('s8', version.numericHandler('sheet_type', p.sheet, 0)), + brooch_index: K.ITEM('s32', version.numericHandler('brooch_index', p.brooch, 0)), hi_speed_level: K.ITEM('s32', p.hispeed), beat_guide: K.ITEM('s8', p.beatGuide), headphone_volume: K.ITEM('s8', p.headphone), judge_bar_pos: K.ITEM('s32', p.judgeBar), music_group: K.ITEM('s32', p.group), - hands_mode: K.ITEM('s8', p.mode), + hands_mode: version.isFirstOrForte() ? K.ITEM('s32', p.mode) : K.ITEM('s8', p.mode), near_setting: K.ITEM('s8', p.near), - judge_delay_offset: K.ITEM('s8', p.offset), + judge_delay_offset: version.isFirstOrForte() ? K.ITEM('s32', p.offset) : K.ITEM('s8', p.offset), bingo_index: K.ITEM('s32', p.bingo), total_skill_value: K.ITEM('u64', BigInt(p.skill)), key_beam_level: K.ITEM('s8', p.keyBeam), @@ -169,14 +194,16 @@ const getPlayerData = async (refid: string, name?: string) => { judge_effect_adjust: K.ITEM('s8', p.judgeFX), simple_bg: K.ITEM('s8', p.simple), }, - brooch_list: { - brooch, + // TODO: Full unlock instead of saving? + cat_progress: { + stair: stairs }, + brooch_list: { brooch }, extra_param: { param }, present_list: {}, various_music_list: { data: [ - K.ATTR({ list_type: '0' }, { + K.ATTR({ list_type: '0' }, { cond_flag: K.ITEM('s32', 0), flag: K.ITEM('s32', 0, { sheet_type: '0' }), }), @@ -202,14 +229,14 @@ export const regist_playdata: EPR = async (info, data, send) => { const name = $(data).str('name'); console.debug(`nos op2 regist: ${name}`); - send.object(await getPlayerData(refid, name)); + send.object(await getPlayerData(refid, info, name)); }; export const get_playdata: EPR = async (info, data, send) => { const refid = $(data).str('refid'); if (!refid) return send.deny(); - send.object(await getPlayerData(refid)); + send.object(await getPlayerData(refid, info)); }; // export const set_stage_result: EPR = async (info, data, send) => { @@ -220,6 +247,7 @@ export const set_total_result: EPR = async (info, data, send) => { const refid = $(data).str('refid'); if (!refid) return send.deny(); + const isForte = new NosVersionHelper(info).isFirstOrForte() const p = await readProfile(refid); p.playCount = $(data).number('play_count', p.playCount); @@ -321,7 +349,7 @@ export const set_total_result: EPR = async (info, data, send) => { // BROOCHES let broochs = $(data).elements('brooch_list.brooch'); for (const brooch of broochs) { - const index = parseInt(_.get(brooch, '@attr.index', '-1')); + const index = parseInt(brooch.attr().index || '-1', 10); if (index < 0) continue; p.brooches[index] = { @@ -335,7 +363,7 @@ export const set_total_result: EPR = async (info, data, send) => { // ISLAND let islands = $(data).elements('island_progress_list.island_progress'); for (const island of islands) { - const index = parseInt(_.get(island, '@attr.index', '-1')); + const index = parseInt(island.attr().index || '-1', 10); if (index < 0) continue; const containers: Profile['islands']['0']['containers'] = {}; @@ -366,6 +394,23 @@ export const set_total_result: EPR = async (info, data, send) => { }; } + // CAT STAIR + let stairs = $(data).elements('cat_progress.stair'); + if (!p.cat_stairs) { + p.cat_stairs = defaultProfile.cat_stairs + } + for (const stair of stairs) { + const index = parseInt(stair.attr().index || '-1', 10); + if (index < 0) continue; + + p.cat_stairs[index] = { + total: stair.number('total_steps', 0), + index: stair.number('chapter_index', 1), + steps: stair.number('chapter_steps', 0), + goal: stair.number('chapter_goal', 0), + }; + } + await writeProfile(refid, p); const scoreData = await readScores(refid); @@ -376,12 +421,12 @@ export const set_total_result: EPR = async (info, data, send) => { const type = stage.attr().sheet_type const key = `${mid}:${type}`; - const c = stage.element('common'); + const c = isForte ? stage : stage.element('common'); const o = _.get(scoreData, `scores.${key}`, {}); const isHigh = c.number('score', 0) >= _.get(o, 'score', 0); scoreData.scores[key] = { score: Math.max(c.number('score', 0), _.get(o, 'score', 0)), - grade: Math.max(c.number('grade_basic', 0), _.get(o, 'grade', 0)), + grade: Math.max(Math.max(c.number('grade_basic', 0), c.number('evaluation', 0)), _.get(o, 'grade', 0)), recital: Math.max(c.number('grade_recital', 0), _.get(o, 'recital', 0)), mode: isHigh ? c.number('hands_mode', 0) : _.get(o, 'mode', 0), count: Math.max(c.number('play_count', 0), _.get(o, 'count', 1)), @@ -393,7 +438,7 @@ export const set_total_result: EPR = async (info, data, send) => { // Save Recitals const rInfo = $(data).element('recital_info.recital'); - if (rInfo){ + if (rInfo) { const rIndex = rInfo.number('recital_index', -1); if (rIndex >= 0) { const r = rInfo.element('result'); @@ -423,6 +468,7 @@ export const get_musicdata: EPR = async (info, data, send) => { const refid = $(data).str('refid'); if (!refid) return send.deny(); + const version = new NosVersionHelper(info) const scoreData = await readScores(refid); const recital_record: any[] = []; @@ -450,18 +496,21 @@ export const get_musicdata: EPR = async (info, data, send) => { const mdata = m.split(':'); const musi = scoreData.scores[m]; + if (parseInt(mdata[0], 10) > version.getMusicMaxIndex()) continue; + music.push(K.ATTR({ - music_index: mdata[0], - sheet_type: mdata[1], - }, { - 'score': K.ITEM('s32', musi.score), - 'grade_basic': K.ITEM('u32', musi.grade), - 'grade_recital': K.ITEM('u32', musi.recital), - 'play_count': K.ITEM('s32', musi.count), - 'clear_count': K.ITEM('s32', musi.clear), - 'multi_count': K.ITEM('s32', musi.multi), - 'hands_mode': K.ITEM('s8', musi.mode), - 'clear_flag': K.ITEM('s32', musi.flag), + music_index: mdata[0], + sheet_type: mdata[1], + }, { + score: K.ITEM('s32', musi.score), + evaluation: K.ITEM('u32', musi.grade), // Forte + grade_basic: K.ITEM('u32', musi.grade), + grade_recital: K.ITEM('u32', musi.recital), + play_count: K.ITEM('s32', musi.count), + clear_count: K.ITEM('s32', musi.clear), + multi_count: K.ITEM('s32', musi.multi), + hands_mode: K.ITEM('s8', musi.mode), + clear_flag: K.ITEM('s32', musi.flag), })); } @@ -472,82 +521,90 @@ export const get_musicdata: EPR = async (info, data, send) => { }; async function readProfile(refid: string): Promise { - const profile = await DB.FindOne(refid, { collection: 'profile'} ) + const profile = await DB.FindOne(refid, { collection: 'profile' }) return profile || defaultProfile } async function writeProfile(refid: string, profile: Profile) { - await DB.Upsert(refid, { collection: 'profile'}, profile) + await DB.Upsert(refid, { collection: 'profile' }, profile) } async function readScores(refid: string): Promise { - const score = await DB.FindOne(refid, { collection: 'scores'} ) - return score || { collection: 'scores', recitals: {}, scores: {}} + const score = await DB.FindOne(refid, { collection: 'scores' }) + return score || { collection: 'scores', recitals: {}, scores: {} } } async function writeScores(refid: string, scores: Scores) { - await DB.Upsert(refid, { collection: 'scores'}, scores) + await DB.Upsert(refid, { collection: 'scores' }, scores) } const defaultProfile: Profile = { - collection: 'profile', + collection: 'profile', - name: 'GUEST', - music: 0, - sheet: 0, - brooch: 0, - hispeed: 0, - beatGuide: 1, - headphone: 0, - judgeBar: 250, - group: 0, - mode: 0, - near: 0, - offset: 0, - bingo: 0, - skill: '0', - playCount: 0, - todayPlayCount: 0, - keyBeam: 0, - orbit: 0, - noteHeight: 10, - noteWidth: 0, - judgeWidth: 0, - beatVolume: 0, - beatType: 0, - keyVolume: 0, - bgmVolume: 0, - note: 0, - sf: 0, - judgeFX: 0, - simple: 0, - money: 0, - fame: 0, - fameId: 0, - island: 0, - brooches: { - '1': { - level: 1, - watch: 0, - steps: 0, - new: 0, - }, - }, - islands: {}, - kentei: {}, - params: { - '1': [0], - }, - musicList: { - type_0: Array(32).fill(-1), - type_1: Array(32).fill(-1), - type_2: Array(32).fill(-1), - type_3: Array(32).fill(-1), - }, - musicList2: { - type_0: Array(32).fill(-1), - type_1: Array(32).fill(-1), - type_2: Array(32).fill(-1), - type_3: Array(32).fill(-1), + name: 'GUEST', + music: 0, + sheet: 0, + brooch: 0, + hispeed: 0, + beatGuide: 1, + headphone: 0, + judgeBar: 250, + group: 0, + mode: 0, + near: 0, + offset: 0, + bingo: 0, + skill: '0', + playCount: 0, + todayPlayCount: 0, + keyBeam: 0, + orbit: 0, + noteHeight: 10, + noteWidth: 0, + judgeWidth: 0, + beatVolume: 0, + beatType: 0, + keyVolume: 0, + bgmVolume: 0, + note: 0, + sf: 0, + judgeFX: 0, + simple: 0, + money: 0, + fame: 0, + fameId: 0, + island: 0, + brooches: { + '1': { + level: 1, + watch: 0, + steps: 0, + new: 0, }, + }, + islands: {}, + kentei: {}, + cat_stairs: { + '0': { + total: 0, + index: 0, + steps: 0, + goal: 0 + } + }, + params: { + '1': [0], + }, + musicList: { + type_0: Array(32).fill(-1), + type_1: Array(32).fill(-1), + type_2: Array(32).fill(-1), + type_3: Array(32).fill(-1), + }, + musicList2: { + type_0: Array(32).fill(-1), + type_1: Array(32).fill(-1), + type_2: Array(32).fill(-1), + type_3: Array(32).fill(-1), + }, } diff --git a/nostalgia@asphyxia/handler/webui.ts b/nostalgia@asphyxia/handler/webui.ts new file mode 100644 index 0000000..9edfbd1 --- /dev/null +++ b/nostalgia@asphyxia/handler/webui.ts @@ -0,0 +1,20 @@ +import { Profile } from "../models/profile"; + +export const fixIndexBug = async (data: { + refid: string; + confirm: string; + }) => { + if (data.confirm == "on") { + console.warn(`refid "${data.refid}" performs index reset!`) + await DB.Update( + data.refid, + { collection: 'profile' }, + { $set: { + music: 0, + sheet: 0, + brooch: 0 + } + } + ); + } + }; \ No newline at end of file diff --git a/nostalgia@asphyxia/index.ts b/nostalgia@asphyxia/index.ts index faad91c..67cb5a3 100644 --- a/nostalgia@asphyxia/index.ts +++ b/nostalgia@asphyxia/index.ts @@ -1,21 +1,24 @@ import { get_common_info, get_music_info } from "./handler/common"; -import { get_musicdata, get_playdata, regist_playdata, set_total_result} from "./handler/player" +import { get_musicdata, get_playdata, regist_playdata, set_total_result } from "./handler/player" +import { fixIndexBug } from "./handler/webui"; export function register() { R.GameCode('PAN'); - + + R.WebUIEvent("nosFixIndexBug", fixIndexBug) + const MultiRoute = (method: string, handler: EPR | boolean) => { - // Helper for register multiple versions. - // But.. only Opus 2 for now. - R.Route(`op2_${method}`, handler); + // Helper for register multiple versions. + R.Route(method, handler); // First version and Forte. + R.Route(`op2_${method}`, handler); }; - const CommonRoute = (method: string, handler: EPR | boolean) => + const CommonRoute = (method: string, handler: EPR | boolean) => MultiRoute(`common.${method}`, handler) - const PlayerRoute = (method: string, handler: EPR | boolean) => + const PlayerRoute = (method: string, handler: EPR | boolean) => MultiRoute(`player.${method}`, handler) - + // Common CommonRoute('get_common_info', get_common_info); CommonRoute('get_music_info', get_music_info); @@ -25,4 +28,13 @@ export function register() { PlayerRoute('get_playdata', get_playdata) PlayerRoute('regist_playdata', regist_playdata) PlayerRoute('set_total_result', set_total_result) + + //TODO: Fix this things with actual working handler. + PlayerRoute('set_stage_result', true) + + R.Unhandled(async (info, data, send) => { + if (["eventlog"].includes(info.module)) return; + console.error(`Received Unhandled Response on ${info.method} by ${info.model}/${info.module}`) + console.error(`Received Request: ${JSON.stringify(data, null, 4)}`) + }) } \ No newline at end of file diff --git a/nostalgia@asphyxia/models/profile.ts b/nostalgia@asphyxia/models/profile.ts index 9b9fa02..c4403a3 100644 --- a/nostalgia@asphyxia/models/profile.ts +++ b/nostalgia@asphyxia/models/profile.ts @@ -1,82 +1,90 @@ export interface Profile { - collection: 'profile', - - name: string; - playCount: number; - todayPlayCount: number; - music: number; - sheet: number; - brooch: number; - hispeed: number; - beatGuide: number; - headphone: number; - judgeBar: number; - group: number; - mode: number; - near: number; - offset: number; - bingo: number; - skill: string; - keyBeam: number; - orbit: number; - noteHeight: number; - noteWidth: number; - judgeWidth: number; - beatVolume: number; - beatType: number; - keyVolume: number; - bgmVolume: number; - note: number; - sf: number; - judgeFX: number; - simple: number; - money: number; - fame: number; - fameId: number; - island: number; - params: { - [key: string]: number[]; + collection: 'profile', + + name: string; + playCount: number; + todayPlayCount: number; + music: number; + sheet: number; + brooch: number; + hispeed: number; + beatGuide: number; + headphone: number; + judgeBar: number; + group: number; + mode: number; + near: number; + offset: number; + bingo: number; + skill: string; + keyBeam: number; + orbit: number; + noteHeight: number; + noteWidth: number; + judgeWidth: number; + beatVolume: number; + beatType: number; + keyVolume: number; + bgmVolume: number; + note: number; + sf: number; + judgeFX: number; + simple: number; + money: number; + fame: number; + fameId: number; + island: number; + params: { + [key: string]: number[]; + }; + brooches: { + [key: string]: { + watch: number; + level: number; + steps: number; + new: number; }; - brooches: { - [key: string]: { - watch: number; - level: number; - steps: number; - new: number; - }; - }; - islands: { - [key: string]: { - look: number; - select: number; - time: number; - containers: { - [key: string]: { - prog: number; - rewards: { [key: string]: number }; - }; + }; + islands: { + [key: string]: { + look: number; + select: number; + time: number; + containers: { + [key: string]: { + prog: number; + rewards: { [key: string]: number }; }; }; }; - kentei: { - [key: string]: { - stage: number; - score: number[]; - rate: number; - flag: number; - count: number; - }; + }; + kentei: { + [key: string]: { + stage: number; + score: number[]; + rate: number; + flag: number; + count: number; }; - musicList: { - type_0: number[]; - type_1: number[]; - type_2: number[]; - type_3: number[]; - }; - musicList2: { - type_0: number[]; - type_1: number[]; - type_2: number[]; - type_3: number[]; - }; - } \ No newline at end of file + }; + cat_stairs: { + [key: string]: { + total: number, + index: number, + steps: number, + goal: number + } + }; + musicList: { + type_0: number[]; + type_1: number[]; + type_2: number[]; + type_3: number[]; + }; + musicList2: { + type_0: number[]; + type_1: number[]; + type_2: number[]; + type_3: number[]; + }; +} \ No newline at end of file diff --git a/nostalgia@asphyxia/models/scores.ts b/nostalgia@asphyxia/models/scores.ts index 7a25669..bcec2ee 100644 --- a/nostalgia@asphyxia/models/scores.ts +++ b/nostalgia@asphyxia/models/scores.ts @@ -1,30 +1,30 @@ export interface Scores { collection: 'scores', - - recitals: { - [key: string]: { - count: number; - hall: number; - cat: number[]; - audience: number; - money: number; - fame: number; - player: number; - score: number; - start: string; - end: string; - }; + + recitals: { + [key: string]: { + count: number; + hall: number; + cat: number[]; + audience: number; + money: number; + fame: number; + player: number; + score: number; + start: string; + end: string; }; - scores: { - [key: string]: { - score: number; - grade: number; - recital: number; - count: number; - clear: number; - multi: number; - mode: number; - flag: number; - }; + }; + scores: { + [key: string]: { + score: number; + grade: number; + recital: number; + count: number; + clear: number; + multi: number; + mode: number; + flag: number; }; - } \ No newline at end of file + }; +} \ No newline at end of file diff --git a/nostalgia@asphyxia/utils.ts b/nostalgia@asphyxia/utils.ts new file mode 100644 index 0000000..b56e6ad --- /dev/null +++ b/nostalgia@asphyxia/utils.ts @@ -0,0 +1,47 @@ +type NostalgiaVersions = 'First' | 'Forte' | 'Op2' | 'Op3' +type NostalgiaNumericTypes = 'music_index' | 'sheet_type' | 'brooch_index' | 'event_index' + +export class NosVersionHelper { + public version: NostalgiaVersions + + private table = { // FIXME: All of Op3 values are placeholder + music_index: { First: 87, Forte: 195, Op2: 315, Op3: 500 }, + brooch_index: { First: 120, Forte: 147, Op2: 148, Op3: 200 }, + sheet_type: { First: 2, Forte: 2, Op2: 3, Op3: 3 }, + event_index: { First: 10, Forte: 10, Op2: 17, Op3: 20 } + } + + constructor (info: EamuseInfo) { + const version = parseInt(info.model.trim().substr(10), 10) + if (version >= 2020000000) { + this.version = 'Op3' + } else if (version >= 2019000000) { + this.version = 'Op2' + } else if (version >= 2018000000) { + this.version = 'Forte' + } else { + this.version = 'First' + } + } + + + getMusicMaxIndex() { + return this.table['music_index'][this.version] + } + + getBroochMaxIndex() { + return this.table['brooch_index'][this.version] + } + + getEventMaxIndex() { + return this.table['event_index'][this.version] + } + + numericHandler(type: NostalgiaNumericTypes, input: number, def: number = 0) { + return input > this.table[type][this.version] ? def : input; + } + + isFirstOrForte() { + return this.version === 'First' || this.version === 'Forte' + } +} \ No newline at end of file diff --git a/nostalgia@asphyxia/webui/profile_fix_login.pug b/nostalgia@asphyxia/webui/profile_fix_login.pug new file mode 100644 index 0000000..76e1271 --- /dev/null +++ b/nostalgia@asphyxia/webui/profile_fix_login.pug @@ -0,0 +1,26 @@ +div + .card + .card-header + p.card-header-title + span.icon + i.mdi.mdi-account-edit + | Fix Error with Login + .card-content + p If you unable to login after travels of between versions, This may helpful. + p Normally, login issue caused you played deleted song last time in previous version that not deleted time. + p This page is about reset of last indexes that causing login problem. + form(method="post" action="/emit/nosFixIndexBug") + .field + label.label ID + .control + input.input(type="text" name="refid", value=refid readonly) + .field + label.label Are you sure to reset indexes? + .control + input(type="checkbox" name="confirm") + | This is not recoverable. Do this if you have a problem. + .field + button.button.is-primary(type="submit") + span.icon + i.mdi.mdi-check + span Submit diff --git a/sdvx@asphyxia/data/vvw.ts b/sdvx@asphyxia/data/vvw.ts index 876e280..2a104a6 100644 --- a/sdvx@asphyxia/data/vvw.ts +++ b/sdvx@asphyxia/data/vvw.ts @@ -13,6 +13,7 @@ export const EVENT5 = [ 'FACTORY\t10', 'CONTINUATION', 'APPEAL_CARD_GEN_NEW_PRICE', + 'APPEAL_CARD_UNLOCK\t0,30170914,0,30171014,0,30171116,0,30180201,0,30180607,0,30181206,0,30200326,0,30200611', 'FAVORITE_APPEALCARD_MAX\t100', 'FAVORITE_MUSIC_MAX\t500', 'EVENTDATE_APRILFOOL', @@ -31,6 +32,7 @@ export const EVENT5 = [ 'CREW_SELECT_ABLE', 'PREMIUM_TIME_ENABLE', 'OMEGA_ENABLE\t1,2,3,4,5,6,7,8,9', + 'HEXA_ENABLE\t1,2,3', ]; export const COURSES5 = [ @@ -2164,7 +2166,7 @@ export const COURSES5 = [ { id: 12, name: 'SKILL ANALYZER 第4回', - isNew: 1, + isNew: 0, courses: [ { id: 1, @@ -2441,31 +2443,645 @@ export const COURSES5 = [ }, ], }, - // { - // id: 12, - // type: 0, - // name: 'SKILL ANALYZER Level.∞', - // level: 12, - // nameID: 12, - // assist: 0, - // tracks: [ - // { - // no: 0, - // mid: 1542, - // mty: 4, - // }, - // { - // no: 1, - // mid: 1498, - // mty: 4, - // }, - // { - // no: 2, - // mid: 1462, // 666 - // mty: 4, - // }, - // ], - // }, + { + id: 12, + type: 0, + name: 'SKILL ANALYZER Level.∞', + level: 12, + nameID: 12, + assist: 0, + tracks: [ + { + no: 0, + mid: 1542, + mty: 4, + }, + { + no: 1, + mid: 1498, + mty: 4, + }, + { + no: 2, + mid: 1580, // 666 + mty: 4, + }, + ], + }, + ], + }, + { + id: 13, + name: 'SKILL ANALYZER 第5回', + isNew: 1, + courses:[ + { + id: 1, + type: 0, + name: 'SKILL ANALYZER Level.01', + level: 1, + nameID: 1, + assist: 0, + tracks: [ + { + no: 0, + mid: 1383, + mty: 0, + }, + { + no: 1, + mid: 303, + mty: 0, + }, + { + no: 2, + mid: 1136, + mty: 0, + }, + ], + }, + { + id: 2, + type: 0, + name: 'SKILL ANALYZER Level.02', + level: 2, + nameID: 2, + assist: 0, + tracks: [ + { + no: 0, + mid: 768, + mty: 1, + }, + { + no: 1, + mid: 138, + mty: 1, + }, + { + no: 2, + mid: 984, + mty: 1, + }, + ], + }, + { + id: 3, + type: 0, + name: 'SKILL ANALYZER Level.03', + level: 3, + nameID: 3, + assist: 0, + tracks: [ + { + no: 0, + mid: 1132, + mty: 1, + }, + { + no: 1, + mid: 608, + mty: 1, + }, + { + no: 2, + mid: 1080, + mty: 1, + }, + ], + }, + { + id: 4, + type: 0, + name: 'SKILL ANALYZER Level.04', + level: 4, + nameID: 4, + assist: 0, + tracks: [ + { + no: 0, + mid: 1387, + mty: 1, + }, + { + no: 1, + mid: 752, + mty: 1, + }, + { + no: 2, + mid: 1342, + mty: 1, + }, + ], + }, + { + id: 5, + type: 0, + name: 'SKILL ANALYZER Level.05', + level: 5, + nameID: 5, + assist: 0, + tracks: [ + { + no: 0, + mid: 1472, + mty: 1, + }, + { + no: 1, + mid: 552, + mty: 1, + }, + { + no: 2, + mid: 1373, + mty: 1, + }, + ], + }, + { + id: 6, + type: 0, + name: 'SKILL ANALYZER Level.06', + level: 6, + nameID: 6, + assist: 0, + tracks: [ + { + no: 0, + mid: 1422, + mty: 2, + }, + { + no: 1, + mid: 184, + mty: 2, + }, + { + no: 2, + mid: 1151, + mty: 2, + }, + ], + }, + { + id: 7, + type: 0, + name: 'SKILL ANALYZER Level.07', + level: 7, + nameID: 7, + assist: 0, + tracks: [ + { + no: 0, + mid: 1449, + mty: 2, + }, + { + no: 1, + mid: 850, + mty: 2, + }, + { + no: 2, + mid: 1007, + mty: 2, + }, + ], + }, + { + id: 8, + type: 0, + name: 'SKILL ANALYZER Level.08', + level: 8, + nameID: 8, + assist: 0, + tracks: [ + { + no: 0, + mid: 553, + mty: 2, + }, + { + no: 1, + mid: 1069, + mty: 4, + }, + { + no: 2, + mid: 1298, + mty: 2, + }, + ], + }, + { + id: 9, + type: 0, + name: 'SKILL ANALYZER Level.09', + level: 9, + nameID: 9, + assist: 0, + tracks: [ + { + no: 0, + mid: 647, + mty: 2, + }, + { + no: 1, + mid: 908, + mty: 2, + }, + { + no: 2, + mid: 1355, + mty: 4, + }, + ], + }, + { + id: 10, + type: 0, + name: 'SKILL ANALYZER Level.10', + level: 10, + nameID: 10, + assist: 0, + tracks: [ + { + no: 0, + mid: 1399, + mty: 4, + }, + { + no: 1, + mid: 836, + mty: 2, + }, + { + no: 2, + mid: 1053, + mty: 4, + }, + ], + }, + { + id: 11, + type: 0, + name: 'SKILL ANALYZER Level.11', + level: 11, + nameID: 11, + assist: 0, + tracks: [ + { + no: 0, + mid: 1308, + mty: 4, + }, + { + no: 1, + mid: 1108, + mty: 4, + }, + { + no: 2, + mid: 1240, + mty: 4, + }, + ], + }, + { + id: 12, + type: 0, + name: 'SKILL ANALYZER Level.∞', + level: 12, + nameID: 12, + assist: 0, + tracks: [ + { + no: 0, + mid: 1583, + mty: 4, + }, + { + no: 1, + mid: 1104, + mty: 4, + }, + { + no: 2, + mid: 1584, + mty: 4, + }, + ], + } + ], + }, + { + id: 14, + name: 'SKILL ANALYZER 第6回', + isNew: 1, + courses:[ + { + id: 1, + type: 0, + name: 'SKILL ANALYZER Level.01', + level: 1, + nameID: 1, + assist: 0, + tracks: [ + { + no: 0, + mid: 1488, + mty: 0, + }, + { + no: 1, + mid: 266, + mty: 1, + }, + { + no: 2, + mid: 51, + mty: 2, + }, + ], + }, + { + id: 2, + type: 0, + name: 'SKILL ANALYZER Level.02', + level: 2, + nameID: 2, + assist: 0, + tracks: [ + { + no: 0, + mid: 167, + mty: 1, + }, + { + no: 1, + mid: 1330, + mty: 1, + }, + { + no: 2, + mid: 923, + mty: 1, + }, + ], + }, + { + id: 3, + type: 0, + name: 'SKILL ANALYZER Level.03', + level: 3, + nameID: 3, + assist: 0, + tracks: [ + { + no: 0, + mid: 419, + mty: 1, + }, + { + no: 1, + mid: 1455, + mty: 1, + }, + { + no: 2, + mid: 1075, + mty: 1, + }, + ], + }, + { + id: 4, + type: 0, + name: 'SKILL ANALYZER Level.04', + level: 4, + nameID: 4, + assist: 0, + tracks: [ + { + no: 0, + mid: 597, + mty: 1, + }, + { + no: 1, + mid: 952, + mty: 1, + }, + { + no: 2, + mid: 1391, + mty: 1, + }, + ], + }, + { + id: 5, + type: 0, + name: 'SKILL ANALYZER Level.05', + level: 5, + nameID: 5, + assist: 0, + tracks: [ + { + no: 0, + mid: 103, + mty: 2, + }, + { + no: 1, + mid: 565, + mty: 2, + }, + { + no: 2, + mid: 933, + mty: 2, + }, + ], + }, + { + id: 6, + type: 0, + name: 'SKILL ANALYZER Level.06', + level: 6, + nameID: 6, + assist: 0, + tracks: [ + { + no: 0, + mid: 1313, + mty: 2, + }, + { + no: 1, + mid: 1469, + mty: 2, + }, + { + no: 2, + mid: 559, + mty: 2, + }, + ], + }, + { + id: 7, + type: 0, + name: 'SKILL ANALYZER Level.07', + level: 7, + nameID: 7, + assist: 0, + tracks: [ + { + no: 0, + mid: 480, + mty: 3, + }, + { + no: 1, + mid: 1540, + mty: 2, + }, + { + no: 2, + mid: 1393, + mty: 2, + }, + ], + }, + { + id: 8, + type: 0, + name: 'SKILL ANALYZER Level.08', + level: 8, + nameID: 8, + assist: 0, + tracks: [ + { + no: 0, + mid: 78, + mty: 2, + }, + { + no: 1, + mid: 576, + mty: 2, + }, + { + no: 2, + mid: 1351, + mty: 4, + }, + ], + }, + { + id: 9, + type: 0, + name: 'SKILL ANALYZER Level.09', + level: 9, + nameID: 9, + assist: 0, + tracks: [ + { + no: 0, + mid: 63, + mty: 2, + }, + { + no: 1, + mid: 228, + mty: 2, + }, + { + no: 2, + mid: 641, + mty: 4, + }, + ], + }, + { + id: 10, + type: 0, + name: 'SKILL ANALYZER Level.10', + level: 10, + nameID: 10, + assist: 0, + tracks: [ + { + no: 0, + mid: 1523, + mty: 4, + }, + { + no: 1, + mid: 1457, + mty: 4, + }, + { + no: 2, + mid: 1061, + mty: 4, + }, + ], + }, + { + id: 11, + type: 0, + name: 'SKILL ANALYZER Level.11', + level: 11, + nameID: 11, + assist: 0, + tracks: [ + { + no: 0, + mid: 1192, + mty: 4, + }, + { + no: 1, + mid: 304, + mty: 3, + }, + { + no: 2, + mid: 679, + mty: 2, + }, + ], + }, + { + id: 12, + type: 0, + name: 'SKILL ANALYZER Level.∞', + level: 12, + nameID: 12, + assist: 0, + tracks: [ + { + no: 0, + mid: 1593, + mty: 4, + }, + { + no: 1, + mid: 1177, + mty: 4, + }, + { + no: 2, + mid: 1660, + mty: 4, + }, + ], + } ], }, ]; diff --git a/sdvx@asphyxia/handlers/common.ts b/sdvx@asphyxia/handlers/common.ts index 55cc402..da45335 100644 --- a/sdvx@asphyxia/handlers/common.ts +++ b/sdvx@asphyxia/handlers/common.ts @@ -24,13 +24,15 @@ export const common: EPR = async (info, data, send) => { let songs = []; if (U.GetConfig('unlock_all_songs')) { - for (let i = 1; i < 1600; ++i) { + for (let i = 1; i < 1700; ++i) { for (let j = 0; j < 5; ++j) { + songs.push({ music_id: K.ITEM('s32', i), music_type: K.ITEM('u8', j), limited: K.ITEM('u8', 3), }); + } } } diff --git a/sdvx@asphyxia/handlers/profiles.ts b/sdvx@asphyxia/handlers/profiles.ts index 0951e73..217fbb2 100644 --- a/sdvx@asphyxia/handlers/profiles.ts +++ b/sdvx@asphyxia/handlers/profiles.ts @@ -253,7 +253,14 @@ export const load: EPR = async (info, data, send) => { const courses = await DB.Find(refid, { collection: 'course' }); const items = await DB.Find(refid, { collection: 'item' }); const params = await DB.Find(refid, { collection: 'param' }); - + let time = new Date(); + let tempHour = time.getHours(); + let tempDate = time.getDate(); + tempHour += 12; + tempDate += 1; + time.setDate(tempDate); + time.setHours(tempHour); + const currentTime = time.getTime(); const mixes = version == 5 ? await getAutomationMixes(params) : []; send.pugFile('templates/load.pug', { @@ -263,6 +270,7 @@ export const load: EPR = async (info, data, send) => { : items, params, skill, + currentTime, mixes, automation: version == 5 ? SDVX_AUTOMATION_SONGS : [], code: IDToCode(profile.id), diff --git a/sdvx@asphyxia/templates/load.pug b/sdvx@asphyxia/templates/load.pug index d6e9ea8..a3dd726 100644 --- a/sdvx@asphyxia/templates/load.pug +++ b/sdvx@asphyxia/templates/load.pug @@ -35,6 +35,8 @@ game packet_booster(__type="s32") 1 if version != 5 block_booster(__type="s32") 1 + blaster_pass_enable(__type="bool") 1 + blaster_pass_limit_date(__type="u64") #{currentTime} eaappli relation(__type="s8") 1