@gracefullight/saju 0.2.0 → 0.4.1

package/dist/core/luck.js

@@ -0,0 +1,137 @@
+import { getStemPolarity } from "../core/ten-gods";
+import { BRANCHES, getPillarIndex, jdnFromDate, pillarFromIndex, STEMS } from "../utils";
+export function calculateMajorLuck(adapter, birthDateTime, gender, yearPillar, monthPillar, options = {}) {
+    const { count = 8 } = options;
+    const yearStem = yearPillar[0];
+    const yearStemPolarity = getStemPolarity(yearStem);
+    const isForward = (yearStemPolarity === "yang" && gender === "male") ||
+        (yearStemPolarity === "yin" && gender === "female");
+    const birthMillis = adapter.toMillis(birthDateTime);
+    const msPerDay = 1000 * 60 * 60 * 24;
+    let daysToTerm;
+    if (options.nextJieMillis !== undefined && options.prevJieMillis !== undefined) {
+        if (isForward) {
+            daysToTerm = Math.abs(options.nextJieMillis - birthMillis) / msPerDay;
+        }
+        else {
+            daysToTerm = Math.abs(birthMillis - options.prevJieMillis) / msPerDay;
+        }
+    }
+    else {
+        daysToTerm = 30;
+    }
+    const totalMonths = Math.round((daysToTerm / 3) * 12);
+    const years = Math.floor(totalMonths / 12);
+    const months = totalMonths % 12;
+    const days = Math.round(((daysToTerm / 3) * 12 - totalMonths) * 30);
+    const startAge = years;
+    const startAgeDetail = { years, months, days: Math.abs(days) };
+    const monthIdx60 = getPillarIndex(monthPillar);
+    const pillars = [];
+    for (let i = 1; i <= count; i++) {
+        const pillarIdx = isForward ? monthIdx60 + i : monthIdx60 - i;
+        const pillar = pillarFromIndex(pillarIdx);
+        pillars.push({
+            index: i,
+            startAge: startAge + (i - 1) * 10,
+            endAge: startAge + i * 10 - 1,
+            stem: pillar[0],
+            branch: pillar[1],
+            pillar,
+        });
+    }
+    return {
+        gender,
+        yearStemPolarity,
+        isForward,
+        startAge,
+        startAgeDetail,
+        daysToTerm: Math.round(daysToTerm * 10) / 10,
+        pillars,
+    };
+}
+export function calculateYearlyLuck(birthYear, fromYear, toYear) {
+    const results = [];
+    for (let year = fromYear; year <= toYear; year++) {
+        const idx60 = (((year - 1984) % 60) + 60) % 60;
+        const pillar = pillarFromIndex(idx60);
+        const age = year - birthYear + 1;
+        results.push({
+            year,
+            stem: pillar[0],
+            branch: pillar[1],
+            pillar,
+            age,
+        });
+    }
+    return results;
+}
+export function getYearPillar(year) {
+    const idx60 = (((year - 1984) % 60) + 60) % 60;
+    return pillarFromIndex(idx60);
+}
+export function getCurrentMajorLuck(majorLuck, age) {
+    for (const pillar of majorLuck.pillars) {
+        if (age >= pillar.startAge && age <= pillar.endAge) {
+            return pillar;
+        }
+    }
+    return null;
+}
+export function calculateMonthlyLuck(year, fromMonth, toMonth) {
+    const results = [];
+    const yearIdx60 = (((year - 1984) % 60) + 60) % 60;
+    const yearStem = STEMS[yearIdx60 % 10];
+    const yearStemIdx = STEMS.indexOf(yearStem);
+    const baseMonthStemIdx = (yearStemIdx * 2 + 2) % 10;
+    for (let month = fromMonth; month <= toMonth; month++) {
+        const monthOffset = month - 1;
+        const stemIdx = (baseMonthStemIdx + monthOffset) % 10;
+        const branchIdx = (monthOffset + 2) % 12;
+        const stem = STEMS[stemIdx];
+        const branch = BRANCHES[branchIdx];
+        const pillar = stem + branch;
+        results.push({
+            year,
+            month,
+            stem,
+            branch,
+            pillar,
+        });
+    }
+    return results;
+}
+export function calculateDailyLuck(year, month, fromDay, toDay) {
+    const results = [];
+    for (let day = fromDay; day <= toDay; day++) {
+        const jdn = jdnFromDate(year, month, day);
+        const idx60 = (((jdn + 49) % 60) + 60) % 60;
+        const stem = STEMS[idx60 % 10];
+        const branch = BRANCHES[idx60 % 12];
+        const pillar = stem + branch;
+        results.push({
+            year,
+            month,
+            day,
+            stem,
+            branch,
+            pillar,
+        });
+    }
+    return results;
+}
+export function getDayPillar(year, month, day) {
+    const jdn = jdnFromDate(year, month, day);
+    const idx60 = (((jdn + 49) % 60) + 60) % 60;
+    return STEMS[idx60 % 10] + BRANCHES[idx60 % 12];
+}
+export function getMonthPillar(year, month) {
+    const yearIdx60 = (((year - 1984) % 60) + 60) % 60;
+    const yearStem = STEMS[yearIdx60 % 10];
+    const yearStemIdx = STEMS.indexOf(yearStem);
+    const baseMonthStemIdx = (yearStemIdx * 2 + 2) % 10;
+    const monthOffset = month - 1;
+    const stemIdx = (baseMonthStemIdx + monthOffset) % 10;
+    const branchIdx = (monthOffset + 2) % 12;
+    return STEMS[stemIdx] + BRANCHES[branchIdx];
+}

package/dist/core/relations.d.ts

@@ -0,0 +1,94 @@
+import type { Element } from "./ten-gods";
+export type TransformationStatus = "합" | "반합" | "화" | "불화";
+export type StemCombinationResult = {
+    stems: [string, string];
+    resultElement: Element;
+};
+export declare const STEM_COMBINATIONS: StemCombinationResult[];
+export type BranchCombinationResult = {
+    branches: [string, string];
+    resultElement: Element;
+};
+export declare const BRANCH_SIX_COMBINATIONS: BranchCombinationResult[];
+export type TripleCombinationResult = {
+    branches: [string, string, string];
+    resultElement: Element;
+};
+export declare const BRANCH_TRIPLE_COMBINATIONS: TripleCombinationResult[];
+export declare const BRANCH_DIRECTIONAL_COMBINATIONS: TripleCombinationResult[];
+export declare const BRANCH_CLASHES: [string, string][];
+export declare const BRANCH_HARMS: [string, string][];
+export declare const BRANCH_PUNISHMENTS: {
+    branches: string[];
+    type: string;
+}[];
+export declare const BRANCH_DESTRUCTIONS: [string, string][];
+export interface StemCombination {
+    type: "천간합";
+    pair: [string, string];
+    positions: [string, string];
+    resultElement: Element;
+    transformStatus: TransformationStatus;
+    transformReason: string;
+}
+export interface BranchSixCombination {
+    type: "육합";
+    pair: [string, string];
+    positions: [string, string];
+    resultElement: Element;
+    transformStatus: TransformationStatus;
+    transformReason: string;
+}
+export interface BranchTripleCombination {
+    type: "삼합";
+    branches: string[];
+    positions: string[];
+    resultElement: Element;
+    isComplete: boolean;
+    transformStatus: TransformationStatus;
+    transformReason: string;
+}
+export interface BranchDirectionalCombination {
+    type: "방합";
+    branches: string[];
+    positions: string[];
+    resultElement: Element;
+    isComplete: boolean;
+    transformStatus: TransformationStatus;
+    transformReason: string;
+}
+export interface BranchClash {
+    type: "충";
+    pair: [string, string];
+    positions: [string, string];
+}
+export interface BranchHarm {
+    type: "해";
+    pair: [string, string];
+    positions: [string, string];
+}
+export interface BranchPunishment {
+    type: "형";
+    branches: string[];
+    positions: string[];
+    punishmentType: string;
+}
+export interface BranchDestruction {
+    type: "파";
+    pair: [string, string];
+    positions: [string, string];
+}
+export type Relation = StemCombination | BranchSixCombination | BranchTripleCombination | BranchDirectionalCombination | BranchClash | BranchHarm | BranchPunishment | BranchDestruction;
+export interface RelationsResult {
+    combinations: (StemCombination | BranchSixCombination | BranchTripleCombination | BranchDirectionalCombination)[];
+    clashes: BranchClash[];
+    harms: BranchHarm[];
+    punishments: BranchPunishment[];
+    destructions: BranchDestruction[];
+    all: Relation[];
+}
+export declare function analyzeRelations(yearPillar: string, monthPillar: string, dayPillar: string, hourPillar: string): RelationsResult;
+export declare function findStemCombination(stem1: string, stem2: string): StemCombinationResult | null;
+export declare function findBranchClash(branch1: string, branch2: string): boolean;
+export declare function findBranchSixCombination(branch1: string, branch2: string): BranchCombinationResult | null;
+//# sourceMappingURL=relations.d.ts.map

package/dist/core/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/core/relations.ts"],"names":[],"mappings":"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"}

package/dist/core/relations.js

@@ -0,0 +1,309 @@
+import { getBranchElement, getStemElement } from "./ten-gods";
+export const STEM_COMBINATIONS = [
+    { stems: ["甲", "己"], resultElement: "earth" },
+    { stems: ["乙", "庚"], resultElement: "metal" },
+    { stems: ["丙", "辛"], resultElement: "water" },
+    { stems: ["丁", "壬"], resultElement: "wood" },
+    { stems: ["戊", "癸"], resultElement: "fire" },
+];
+export const BRANCH_SIX_COMBINATIONS = [
+    { branches: ["子", "丑"], resultElement: "earth" },
+    { branches: ["寅", "亥"], resultElement: "wood" },
+    { branches: ["卯", "戌"], resultElement: "fire" },
+    { branches: ["辰", "酉"], resultElement: "metal" },
+    { branches: ["巳", "申"], resultElement: "water" },
+    { branches: ["午", "未"], resultElement: "earth" },
+];
+export const BRANCH_TRIPLE_COMBINATIONS = [
+    { branches: ["寅", "午", "戌"], resultElement: "fire" },
+    { branches: ["申", "子", "辰"], resultElement: "water" },
+    { branches: ["亥", "卯", "未"], resultElement: "wood" },
+    { branches: ["巳", "酉", "丑"], resultElement: "metal" },
+];
+export const BRANCH_DIRECTIONAL_COMBINATIONS = [
+    { branches: ["寅", "卯", "辰"], resultElement: "wood" },
+    { branches: ["巳", "午", "未"], resultElement: "fire" },
+    { branches: ["申", "酉", "戌"], resultElement: "metal" },
+    { branches: ["亥", "子", "丑"], resultElement: "water" },
+];
+export const BRANCH_CLASHES = [
+    ["子", "午"],
+    ["丑", "未"],
+    ["寅", "申"],
+    ["卯", "酉"],
+    ["辰", "戌"],
+    ["巳", "亥"],
+];
+export const BRANCH_HARMS = [
+    ["子", "未"],
+    ["丑", "午"],
+    ["寅", "巳"],
+    ["卯", "辰"],
+    ["申", "亥"],
+    ["酉", "戌"],
+];
+export const BRANCH_PUNISHMENTS = [
+    { branches: ["寅", "巳", "申"], type: "무은지형" },
+    { branches: ["丑", "戌", "未"], type: "시세지형" },
+    { branches: ["子", "卯"], type: "무례지형" },
+    { branches: ["辰", "辰"], type: "자형" },
+    { branches: ["午", "午"], type: "자형" },
+    { branches: ["酉", "酉"], type: "자형" },
+    { branches: ["亥", "亥"], type: "자형" },
+];
+export const BRANCH_DESTRUCTIONS = [
+    ["子", "酉"],
+    ["丑", "辰"],
+    ["寅", "亥"],
+    ["卯", "午"],
+    ["巳", "申"],
+    ["未", "戌"],
+];
+const MONTH_BRANCH_ELEMENT_SUPPORT = {
+    寅: ["wood"],
+    卯: ["wood"],
+    辰: ["wood", "earth", "water"],
+    巳: ["fire"],
+    午: ["fire"],
+    未: ["fire", "earth"],
+    申: ["metal"],
+    酉: ["metal"],
+    戌: ["metal", "earth", "fire"],
+    亥: ["water"],
+    子: ["water"],
+    丑: ["water", "earth", "metal"],
+};
+function checkTransformationCondition(resultElement, monthBranch, allBranches, isComplete) {
+    const supportedElements = MONTH_BRANCH_ELEMENT_SUPPORT[monthBranch] || [];
+    const hasMonthSupport = supportedElements.includes(resultElement);
+    const branchElements = allBranches.map((b) => getBranchElement(b));
+    const resultElementCount = branchElements.filter((e) => e === resultElement).length;
+    const hasStrengthSupport = resultElementCount >= 2;
+    if (!isComplete) {
+        return { status: "반합", reason: "불완전 합 - 일부 지지 부재" };
+    }
+    if (hasMonthSupport) {
+        return { status: "화", reason: `월령(${monthBranch})이 ${resultElement}을(를) 지지` };
+    }
+    if (hasStrengthSupport) {
+        return { status: "화", reason: `${resultElement} 기세 충분(${resultElementCount}개)` };
+    }
+    return { status: "불화", reason: "월령 및 기세 미충족으로 화 불성립" };
+}
+function checkStemTransformationCondition(resultElement, monthBranch, allStems) {
+    const supportedElements = MONTH_BRANCH_ELEMENT_SUPPORT[monthBranch] || [];
+    const hasMonthSupport = supportedElements.includes(resultElement);
+    const stemElements = allStems.map((s) => getStemElement(s));
+    const resultElementCount = stemElements.filter((e) => e === resultElement).length;
+    const hasStrengthSupport = resultElementCount >= 2;
+    if (hasMonthSupport) {
+        return { status: "화", reason: `월령(${monthBranch})이 ${resultElement}을(를) 지지` };
+    }
+    if (hasStrengthSupport) {
+        return { status: "화", reason: `${resultElement} 기세 충분(${resultElementCount}개)` };
+    }
+    return { status: "불화", reason: "월령 및 기세 미충족으로 화 불성립" };
+}
+export function analyzeRelations(yearPillar, monthPillar, dayPillar, hourPillar) {
+    const monthBranch = monthPillar[1];
+    const stems = [
+        { char: yearPillar[0], position: "year" },
+        { char: monthPillar[0], position: "month" },
+        { char: dayPillar[0], position: "day" },
+        { char: hourPillar[0], position: "hour" },
+    ];
+    const branches = [
+        { char: yearPillar[1], position: "year" },
+        { char: monthPillar[1], position: "month" },
+        { char: dayPillar[1], position: "day" },
+        { char: hourPillar[1], position: "hour" },
+    ];
+    const allStemChars = stems.map((s) => s.char);
+    const allBranchChars = branches.map((b) => b.char);
+    const combinations = [];
+    const clashes = [];
+    const harms = [];
+    const punishments = [];
+    const destructions = [];
+    for (let i = 0; i < stems.length; i++) {
+        for (let j = i + 1; j < stems.length; j++) {
+            const s1 = stems[i];
+            const s2 = stems[j];
+            for (const combo of STEM_COMBINATIONS) {
+                if ((s1.char === combo.stems[0] && s2.char === combo.stems[1]) ||
+                    (s1.char === combo.stems[1] && s2.char === combo.stems[0])) {
+                    const transform = checkStemTransformationCondition(combo.resultElement, monthBranch, allStemChars);
+                    combinations.push({
+                        type: "천간합",
+                        pair: [s1.char, s2.char],
+                        positions: [s1.position, s2.position],
+                        resultElement: combo.resultElement,
+                        transformStatus: transform.status,
+                        transformReason: transform.reason,
+                    });
+                }
+            }
+        }
+    }
+    for (let i = 0; i < branches.length; i++) {
+        for (let j = i + 1; j < branches.length; j++) {
+            const b1 = branches[i];
+            const b2 = branches[j];
+            for (const combo of BRANCH_SIX_COMBINATIONS) {
+                if ((b1.char === combo.branches[0] && b2.char === combo.branches[1]) ||
+                    (b1.char === combo.branches[1] && b2.char === combo.branches[0])) {
+                    const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, true);
+                    combinations.push({
+                        type: "육합",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                        resultElement: combo.resultElement,
+                        transformStatus: transform.status,
+                        transformReason: transform.reason,
+                    });
+                }
+            }
+            for (const clash of BRANCH_CLASHES) {
+                if ((b1.char === clash[0] && b2.char === clash[1]) ||
+                    (b1.char === clash[1] && b2.char === clash[0])) {
+                    clashes.push({
+                        type: "충",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+            for (const harm of BRANCH_HARMS) {
+                if ((b1.char === harm[0] && b2.char === harm[1]) ||
+                    (b1.char === harm[1] && b2.char === harm[0])) {
+                    harms.push({
+                        type: "해",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+            for (const dest of BRANCH_DESTRUCTIONS) {
+                if ((b1.char === dest[0] && b2.char === dest[1]) ||
+                    (b1.char === dest[1] && b2.char === dest[0])) {
+                    destructions.push({
+                        type: "파",
+                        pair: [b1.char, b2.char],
+                        positions: [b1.position, b2.position],
+                    });
+                }
+            }
+        }
+    }
+    const branchChars = branches.map((b) => b.char);
+    for (const combo of BRANCH_TRIPLE_COMBINATIONS) {
+        const matched = combo.branches.filter((b) => branchChars.includes(b));
+        if (matched.length >= 2) {
+            // biome-ignore lint/style/noNonNullAssertion: matched is filtered from branchChars, find is guaranteed
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            const isComplete = matched.length === 3;
+            const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, isComplete);
+            combinations.push({
+                type: "삼합",
+                branches: matched,
+                positions,
+                resultElement: combo.resultElement,
+                isComplete,
+                transformStatus: transform.status,
+                transformReason: transform.reason,
+            });
+        }
+    }
+    for (const combo of BRANCH_DIRECTIONAL_COMBINATIONS) {
+        const matched = combo.branches.filter((b) => branchChars.includes(b));
+        if (matched.length >= 2) {
+            // biome-ignore lint/style/noNonNullAssertion: matched is filtered from branchChars, find is guaranteed
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            const isComplete = matched.length === 3;
+            const transform = checkTransformationCondition(combo.resultElement, monthBranch, allBranchChars, isComplete);
+            combinations.push({
+                type: "방합",
+                branches: matched,
+                positions,
+                resultElement: combo.resultElement,
+                isComplete,
+                transformStatus: transform.status,
+                transformReason: transform.reason,
+            });
+        }
+    }
+    for (const punishment of BRANCH_PUNISHMENTS) {
+        const matched = punishment.branches.filter((b) => branchChars.includes(b));
+        const isTriple = punishment.branches.length === 3;
+        const isSelfPunishment = punishment.type === "자형";
+        if (isSelfPunishment) {
+            const count = branchChars.filter((b) => b === punishment.branches[0]).length;
+            if (count >= 2) {
+                punishments.push({
+                    type: "형",
+                    branches: Array(count).fill(punishment.branches[0]),
+                    positions: branches
+                        .filter((b) => b.char === punishment.branches[0])
+                        .map((b) => b.position),
+                    punishmentType: punishment.type,
+                });
+            }
+        }
+        else if (isTriple && matched.length >= 2) {
+            // biome-ignore lint/style/noNonNullAssertion: matched is filtered from branchChars, find is guaranteed
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            punishments.push({
+                type: "형",
+                branches: matched,
+                positions,
+                punishmentType: punishment.type,
+            });
+        }
+        else if (!isTriple && matched.length === 2) {
+            // biome-ignore lint/style/noNonNullAssertion: matched is filtered from branchChars, find is guaranteed
+            const positions = matched.map((m) => branches.find((b) => b.char === m).position);
+            punishments.push({
+                type: "형",
+                branches: matched,
+                positions,
+                punishmentType: punishment.type,
+            });
+        }
+    }
+    const all = [...combinations, ...clashes, ...harms, ...punishments, ...destructions];
+    return {
+        combinations,
+        clashes,
+        harms,
+        punishments,
+        destructions,
+        all,
+    };
+}
+export function findStemCombination(stem1, stem2) {
+    for (const combo of STEM_COMBINATIONS) {
+        if ((stem1 === combo.stems[0] && stem2 === combo.stems[1]) ||
+            (stem1 === combo.stems[1] && stem2 === combo.stems[0])) {
+            return combo;
+        }
+    }
+    return null;
+}
+export function findBranchClash(branch1, branch2) {
+    for (const clash of BRANCH_CLASHES) {
+        if ((branch1 === clash[0] && branch2 === clash[1]) ||
+            (branch1 === clash[1] && branch2 === clash[0])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function findBranchSixCombination(branch1, branch2) {
+    for (const combo of BRANCH_SIX_COMBINATIONS) {
+        if ((branch1 === combo.branches[0] && branch2 === combo.branches[1]) ||
+            (branch1 === combo.branches[1] && branch2 === combo.branches[0])) {
+            return combo;
+        }
+    }
+    return null;
+}

package/dist/core/sinsals.d.ts

@@ -0,0 +1,19 @@
+import type { PillarPosition } from "../types";
+export declare const SINSALS: readonly ["peachBlossom", "skyHorse", "floweryCanopy", "ghostGate", "solitaryStar", "widowStar", "heavenlyVirtue", "monthlyVirtue", "skyNoble", "moonNoble", "literaryNoble", "academicHall", "bloodKnife", "sixHarms", "whiteCloth", "heavenlyDoctor"];
+export type Sinsal = (typeof SINSALS)[number];
+export interface SinsalMatch {
+    sinsal: Sinsal;
+    position: PillarPosition;
+}
+export interface SinsalResult {
+    matches: SinsalMatch[];
+    summary: Partial<Record<Sinsal, PillarPosition[]>>;
+}
+export declare function analyzeSinsals(yearPillar: string, monthPillar: string, dayPillar: string, hourPillar: string): SinsalResult;
+export declare const SINSAL_INFO: Record<Sinsal, {
+    korean: string;
+    hanja: string;
+    meaning: string;
+    type: "auspicious" | "inauspicious" | "neutral";
+}>;
+//# sourceMappingURL=sinsals.d.ts.map

package/dist/core/sinsals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sinsals.d.ts","sourceRoot":"","sources":["../../src/core/sinsals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,OAAO,yPAiBV,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AA+L9C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;CACpD;AA6CD,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,GACjB,YAAY,CAoId;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAC9B,MAAM,EACN;IACE,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,YAAY,GAAG,cAAc,GAAG,SAAS,CAAC;CACjD,CAmFF,CAAC"}