vidspotai-shared 1.0.68 → 1.0.69-dev.0

package/lib/services/aiGen/providers/kling/kling.service.js

@@ -6,6 +6,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KlingService = void 0;
 const axios_1 = __importDefault(require("axios"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
 const aiModels_1 = require("../../../../globals/aiModels");
 const types_1 = require("../../../../globals/types");
@@ -16,12 +18,22 @@ const types_2 = require("../../types");
 const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
 const helpers_2 = require("../../../../utils/helpers");
 const errors_1 = require("../../../../utils/errors");
+const cameraAdapter_1 = require("./cameraAdapter");
 class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
     constructor() {
         super();
         this.baseUrl = "https://api-singapore.klingai.com";
         this.generateTimeout = 120000; // 2 min — submit endpoint can be slow under Kling load
         this.statusTimeout = 60000; // 1 min — status/poll should be fast
+        // Force IPv4 for every outbound Kling call. Kling's edges (both
+        // api-singapore.klingai.com and the CDN where video URLs are hosted) have
+        // had IPv6 routes that black-hole from some networks, producing
+        // `AggregateError(ETIMEDOUT)` when node's happy-eyeballs aggregates the
+        // dead v6 leg with the (sometimes also slow) v4 leg. Pinning v4 +
+        // keep-alive avoids the dead-end and reuses the warm socket across
+        // submit / poll / download for the same task.
+        this.v4HttpAgent = new http_1.default.Agent({ family: 4, keepAlive: true });
+        this.v4HttpsAgent = new https_1.default.Agent({ family: 4, keepAlive: true });
         if (!process.env.KLING_SECRET_KEY || !process.env.KLING_ACCESS_KEY) {
             throw new Error("Missing KLING_SECRET_KEY or KLING_ACCESS_KEY in environment variables");
         }
@@ -36,6 +48,8 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             },
             timeout,
             data: body,
+            httpAgent: this.v4HttpAgent,
+            httpsAgent: this.v4HttpsAgent,
         };
         const response = await axios_1.default.request(config);
         if (response.status < 200 || response.status >= 300) {
@@ -48,20 +62,250 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         if (params.modelKey === "kling-avatar") {
             return this.generateAvatarVideo(params);
         }
+        if (params.modelKey === "kling-lip-sync") {
+            return this.generateLipSync(params);
+        }
+        if (params.modelKey === "kling-motion-control") {
+            return this.generateMotionControl(params);
+        }
+        if (params.modelKey === "kling-video-o1" ||
+            params.modelKey === "kling-v3-omni-video") {
+            return this.generateOmniVideo(params);
+        }
+        if (params.endpoint === "extend") {
+            return this.extendVideo(params);
+        }
         const modelId = aiModels_1.aiModelConfigs[params.modelKey]?.modelId;
         if (!modelId)
             throw new Error(`Unknown modelKey: ${params.modelKey}`);
-        const request = {
+        // Common optional fields shared by text2video and image2video endpoints.
+        const optional = {};
+        if (params.negativePrompt)
+            optional.negative_prompt = params.negativePrompt;
+        if (params.cfgScale !== undefined)
+            optional.cfg_scale = params.cfgScale;
+        if (params.callbackUrl)
+            optional.callback_url = params.callbackUrl;
+        if (params.externalTaskId)
+            optional.external_task_id = params.externalTaskId;
+        if (params.cameraControl) {
+            const cc = (0, cameraAdapter_1.toKlingCameraControl)(params.cameraControl);
+            if (cc)
+                optional.camera_control = cc;
+        }
+        // v2.6 uses `sound: "on"|"off"` as a pricing-tier toggle. v3 uses
+        // `generate_audio: boolean` for native audio synthesis. Route by model.
+        if (params.audio !== undefined) {
+            if (params.modelKey === "kling-v3.0") {
+                optional.generate_audio = Boolean(params.audio);
+            }
+            else if (params.modelKey === "kling-v2.6") {
+                optional.sound = params.audio ? "on" : "off";
+            }
+        }
+        const isImageToVideo = !!params.inputImageUrl;
+        const endpoint = isImageToVideo ? "/v1/videos/image2video" : "/v1/videos/text2video";
+        let request;
+        if (isImageToVideo) {
+            const i2v = {
+                model_name: modelId,
+                prompt: params.prompt,
+                image: params.inputImageUrl,
+                duration: params.duration || 5,
+                mode: params.mode || types_2.EVideoMode.STANDARD,
+                ...optional,
+            };
+            if (params.aspectRatio)
+                i2v.aspect_ratio = params.aspectRatio;
+            if (params.lastFrameImageUrl)
+                i2v.image_tail = params.lastFrameImageUrl;
+            if (params.staticMaskUrl)
+                i2v.static_mask = params.staticMaskUrl;
+            if (params.dynamicMasks?.length) {
+                i2v.dynamic_masks = params.dynamicMasks.slice(0, 6).map((d) => ({
+                    mask: d.maskUrl,
+                    trajectories: d.trajectories,
+                }));
+            }
+            request = i2v;
+        }
+        else {
+            request = {
+                model_name: modelId,
+                prompt: params.prompt,
+                aspect_ratio: params.aspectRatio || "16:9",
+                duration: params.duration || 5,
+                mode: params.mode || types_2.EVideoMode.STANDARD,
+                ...optional,
+            };
+        }
+        const starttime = Date.now();
+        const task = await this.requestWithTimeoutRetry(endpoint, "POST", request, 4, this.generateTimeout);
+        logger_1.logger.info("Kling generateVideo submitted", {
+            modelKey: params.modelKey,
+            taskId: task.data.task_id,
+            durationMs: Date.now() - starttime,
+        });
+        return { task: task.data.task_id, status: types_1.EVideoSceneStatus.TRIGGERED };
+    }
+    /**
+     * Extend a previously-generated Kling video by ~4-5s. Takes the Kling task id
+     * of the source video (must have been generated by this Kling account).
+     * Cost is the same per-second as the base model.
+     */
+    async extendVideo(params) {
+        if (!params.sourceTaskId) {
+            throw new Error("sourceTaskId (prior Kling task id) is required for video extension");
+        }
+        const body = { video_id: params.sourceTaskId };
+        if (params.prompt)
+            body.prompt = params.prompt;
+        if (params.negativePrompt)
+            body.negative_prompt = params.negativePrompt;
+        if (params.cfgScale !== undefined)
+            body.cfg_scale = params.cfgScale;
+        if (params.callbackUrl)
+            body.callback_url = params.callbackUrl;
+        if (params.externalTaskId)
+            body.external_task_id = params.externalTaskId;
+        const starttime = Date.now();
+        const task = await this.requestWithTimeoutRetry("/v1/videos/video-extend", "POST", body, 4, this.generateTimeout);
+        logger_1.logger.info("Kling extendVideo submitted", {
+            sourceTaskId: params.sourceTaskId,
+            taskId: task.data.task_id,
+            durationMs: Date.now() - starttime,
+        });
+        return { task: task.data.task_id, status: types_1.EVideoSceneStatus.TRIGGERED };
+    }
+    // ─── OmniVideo (/v1/videos/omni-video) ──────────────────────────────────────
+    async generateOmniVideo(params) {
+        const modelId = aiModels_1.aiModelConfigs[params.modelKey]?.modelId;
+        if (!modelId)
+            throw new Error(`Unknown modelKey: ${params.modelKey}`);
+        const body = {
             model_name: modelId,
-            prompt: params.prompt,
-            aspect_ratio: params.aspectRatio || "16:9",
-            duration: params.duration || 5,
             mode: params.mode || types_2.EVideoMode.STANDARD,
+            duration: String(params.duration ?? 5),
         };
+        if (params.prompt)
+            body.prompt = params.prompt;
+        if (params.aspectRatio)
+            body.aspect_ratio = params.aspectRatio;
+        if (params.callbackUrl)
+            body.callback_url = params.callbackUrl;
+        if (params.externalTaskId)
+            body.external_task_id = params.externalTaskId;
+        if (params.audio !== undefined)
+            body.sound = params.audio ? "on" : "off";
+        // Build image_list: start frame, end frame, plain reference images.
+        const imageList = [];
+        if (params.inputImageUrl) {
+            imageList.push({ image_url: params.inputImageUrl, type: "first_frame" });
+        }
+        if (params.lastFrameImageUrl) {
+            imageList.push({ image_url: params.lastFrameImageUrl, type: "end_frame" });
+        }
+        for (const url of params.referenceImageUrls ?? []) {
+            imageList.push({ image_url: url });
+        }
+        if (imageList.length)
+            body.image_list = imageList;
+        // Build video_list: reference videos (feature type) or base videos (editing).
+        if (params.referenceVideoUrls?.length) {
+            body.video_list = params.referenceVideoUrls.map((url) => ({
+                video_url: url,
+                refer_type: "feature",
+            }));
+        }
+        // Multi-shot support. MultiShot is Shot[] directly (not { shots: Shot[] }).
+        if (params.multiShot?.length) {
+            body.multi_shot = true;
+            body.shot_type = "customize";
+            body.multi_prompt = params.multiShot.map((s, i) => ({
+                index: i + 1,
+                prompt: s.prompt,
+                ...(s.duration !== undefined ? { duration: String(s.duration) } : {}),
+            }));
+        }
         const starttime = Date.now();
-        const task = await this.requestWithTimeoutRetry("/v1/videos/text2video", "POST", request, 4, this.generateTimeout);
-        logger_1.logger.info("Kling generateVideo submitted", {
+        const task = await this.requestWithTimeoutRetry("/v1/videos/omni-video", "POST", body, 4, this.generateTimeout);
+        logger_1.logger.info("Kling generateOmniVideo submitted", {
             modelKey: params.modelKey,
+            modelId,
+            taskId: task.data.task_id,
+            durationMs: Date.now() - starttime,
+        });
+        return { task: task.data.task_id, status: types_1.EVideoSceneStatus.TRIGGERED };
+    }
+    // ─── Motion Control (/v1/videos/motion-control) ──────────────────────────────
+    async generateMotionControl(params) {
+        if (!params.inputImageUrl) {
+            throw new Error("inputImageUrl (character reference image) is required for motion control");
+        }
+        if (!params.inputVideoUrl) {
+            throw new Error("inputVideoUrl (motion reference video) is required for motion control");
+        }
+        const modelId = aiModels_1.aiModelConfigs[params.modelKey]?.modelId ?? "kling-v3";
+        const body = {
+            model_name: modelId,
+            image_url: params.inputImageUrl,
+            video_url: params.inputVideoUrl,
+        };
+        if (params.prompt)
+            body.prompt = params.prompt;
+        if (params.mode)
+            body.mode = params.mode;
+        if (params.callbackUrl)
+            body.callback_url = params.callbackUrl;
+        if (params.externalTaskId)
+            body.external_task_id = params.externalTaskId;
+        const starttime = Date.now();
+        const task = await this.requestWithTimeoutRetry("/v1/videos/motion-control", "POST", body, 4, this.generateTimeout);
+        logger_1.logger.info("Kling generateMotionControl submitted", {
+            taskId: task.data.task_id,
+            durationMs: Date.now() - starttime,
+        });
+        return { task: task.data.task_id, status: types_1.EVideoSceneStatus.TRIGGERED };
+    }
+    // ─── Lip Sync (/v1/videos/identify-face + /v1/videos/advanced-lip-sync) ─────
+    async generateLipSync(params) {
+        if (!params.inputVideoUrl) {
+            throw new Error("inputVideoUrl (source video) is required for lip sync");
+        }
+        if (!params.inputAudioUrl) {
+            throw new Error("inputAudioUrl (audio file) is required for lip sync");
+        }
+        // Step 1: identify faces in the source video (synchronous endpoint).
+        const faceRequest = { video_url: params.inputVideoUrl };
+        const faceResp = await this.requestWithTimeoutRetry("/v1/videos/identify-face", "POST", faceRequest, 2, this.generateTimeout);
+        if (faceResp.code !== 0) {
+            throw new Error(`Kling identify-face failed (code ${faceResp.code}): ${faceResp.message}`);
+        }
+        if (!faceResp.data.face_data?.length) {
+            throw new Error("Kling identify-face: no faces detected in source video");
+        }
+        // Auto-select the first detected face.
+        const face = faceResp.data.face_data[0];
+        const audioDurationMs = params.audioDurationMs ?? 60000;
+        const lipSyncBody = {
+            session_id: faceResp.data.session_id,
+            face_choose: [{
+                    face_id: face.face_id,
+                    sound_file: params.inputAudioUrl,
+                    sound_insert_time: face.start_time,
+                    sound_start_time: 0,
+                    sound_end_time: audioDurationMs,
+                    sound_volume: 1,
+                    original_audio_volume: 1,
+                }],
+            ...(params.callbackUrl ? { callback_url: params.callbackUrl } : {}),
+            ...(params.externalTaskId ? { external_task_id: params.externalTaskId } : {}),
+        };
+        const starttime = Date.now();
+        const task = await this.requestWithTimeoutRetry("/v1/videos/advanced-lip-sync", "POST", lipSyncBody, 4, this.generateTimeout);
+        logger_1.logger.info("Kling generateLipSync submitted", {
+            sessionId: faceResp.data.session_id,
+            faceId: face.face_id,
             taskId: task.data.task_id,
             durationMs: Date.now() - starttime,
         });
@@ -79,6 +323,8 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
             sound_file: params.inputAudioUrl,
             prompt: params.prompt,
             mode: params.mode || "std",
+            ...(params.callbackUrl ? { callback_url: params.callbackUrl } : {}),
+            ...(params.externalTaskId ? { external_task_id: params.externalTaskId } : {}),
         };
         const starttime = Date.now();
         // Use requestWithTimeoutRetry so transient Kling server slowness doesn't fail the job outright.
@@ -169,14 +415,35 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
     }
     async checkRegularVideoStatus({ task, outputFilename, outputFilePath = "videos", }) {
         const startTime = Date.now();
-        const result = await this.requestWithTimeoutRetry(`/v1/videos/text2video/${task}`, "GET");
-        logger_1.logger.info("Kling checkVideoStatus polled", { task, durationMs: Date.now() - startTime, status: result?.data?.task_status });
+        // Try each Kling status endpoint in order until one returns non-404.
+        // We don't persist which endpoint was used at submit time, so we probe all of them.
+        const statusEndpoints = [
+            `/v1/videos/text2video/${task}`,
+            `/v1/videos/image2video/${task}`,
+            `/v1/videos/video-extend/${task}`,
+            `/v1/videos/omni-video/${task}`,
+            `/v1/videos/motion-control/${task}`,
+            `/v1/videos/advanced-lip-sync/${task}`,
+        ];
+        let result;
+        for (const ep of statusEndpoints) {
+            try {
+                result = await this.requestWithTimeoutRetry(ep, "GET");
+                break; // found it
+            }
+            catch (err) {
+                if (err.response?.status !== 404)
+                    throw err;
+                // 404 → try next endpoint
+            }
+        }
         if (!result) {
             return {
                 status: types_1.EVideoSceneStatus.FAILED,
-                errorMessage: "No response from Kling API",
+                errorMessage: `Task ${task} not found on any Kling status endpoint`,
             };
         }
+        logger_1.logger.info("Kling checkVideoStatus polled", { task, durationMs: Date.now() - startTime, status: result.data.task_status });
         if (result.data.task_status === "succeed") {
             const videoUrl = result.data.task_result?.videos?.[0]?.url;
             if (!videoUrl) {
@@ -230,22 +497,74 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
                     errorMessage: "No video URL in avatar response",
                 };
             }
+            // Kling task is done. Now download from Kling's CDN, push to GCS, and
+            // mint a signed URL. Any of these three can hiccup (Kling CDN slow,
+            // GCS 503, signedURL service blip) — historically the whole call threw
+            // and the outer TaskPoller burned a poll attempt re-asking Kling for a
+            // status that's already known. Wrap the post-success work in its own
+            // bounded retry so a transient blip doesn't poison the poll loop.
             const filePath = `${outputFilePath}/${outputFilename}.mp4`;
             const file = (0, firebase_1.getBucket)().file(filePath);
-            const videoResp = await axios_1.default.get(videoUrl, {
-                responseType: "arraybuffer",
-                timeout: this.generateTimeout,
-            });
-            const buffer = Buffer.from(videoResp.data);
-            await file.save(buffer, { contentType: "video/mp4" });
-            const [signedUrl] = await file.getSignedUrl({
-                action: "read",
-                expires: "03-09-2491",
-            });
-            return {
-                videoUrl: signedUrl,
-                status: types_1.EVideoSceneStatus.COMPLETED,
-            };
+            const maxAttempts = 3;
+            let lastErr;
+            // Force IPv4 on the download. The Kling-returned video URL frequently
+            // resolves to a CDN host where IPv6 is broken or routes us to a
+            // geo-blocked PoP, producing an AggregateError(ETIMEDOUT) where both
+            // happy-eyeballs sockets fail. Pinning v4 avoids the IPv6 dead-end.
+            const v4Http = new http_1.default.Agent({ family: 4, keepAlive: true });
+            const v4Https = new https_1.default.Agent({ family: 4, keepAlive: true });
+            // Parse host so we can log which CDN we couldn't reach.
+            let downloadHost = "unknown";
+            try {
+                downloadHost = new URL(videoUrl).host;
+            }
+            catch {
+                /* leave as unknown */
+            }
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                try {
+                    const videoResp = await axios_1.default.get(videoUrl, {
+                        responseType: "arraybuffer",
+                        timeout: this.generateTimeout,
+                        httpAgent: v4Http,
+                        httpsAgent: v4Https,
+                    });
+                    const buffer = Buffer.from(videoResp.data);
+                    await file.save(buffer, { contentType: "video/mp4" });
+                    const [signedUrl] = await file.getSignedUrl({
+                        action: "read",
+                        expires: "03-09-2491",
+                    });
+                    return {
+                        videoUrl: signedUrl,
+                        status: types_1.EVideoSceneStatus.COMPLETED,
+                    };
+                }
+                catch (err) {
+                    lastErr = err;
+                    const isErr = err instanceof Error;
+                    logger_1.logger.warn("Kling avatar post-success stash failed", {
+                        task,
+                        attempt,
+                        maxAttempts,
+                        downloadHost,
+                        errName: isErr ? err.name : typeof err,
+                        errCode: isErr ? err.code : undefined,
+                        httpStatus: isErr ? err.response?.status : undefined,
+                        msg: isErr ? err.message : String(err),
+                    });
+                    if (attempt < maxAttempts) {
+                        await new Promise((r) => setTimeout(r, 2000 * 2 ** (attempt - 1)));
+                    }
+                }
+            }
+            // All internal retries exhausted — surface as pending so the outer
+            // TaskPoller retries the WHOLE checkVideoStatus call (with its own
+            // budget). Throwing here would burn an outer attempt with no extra
+            // signal beyond what we already logged.
+            throw lastErr instanceof Error
+                ? lastErr
+                : new Error(`Kling avatar stash failed after ${maxAttempts} attempts`);
         }
         if (result.data.task_status === "failed") {
             return {
@@ -267,15 +586,27 @@ class KlingService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         };
         return jsonwebtoken_1.default.sign(payload, process.env.KLING_SECRET_KEY, options);
     }
-    getCreditUsed({ modelKey, mode = types_2.EVideoMode.PROFESSIONAL, duration = 5, multiClip = false, }) {
+    getCreditUsed({ modelKey, mode = types_2.EVideoMode.PROFESSIONAL, duration = 5, multiClip = false, audio = false, }) {
         const modelConfig = aiModels_1.aiModelConfigs[modelKey];
         const applyFloor = !multiClip;
-        // Avatar: per-second pricing based on mode (cost.perMode[mode].perSecond)
+        // Avatar: per-second pricing based on mode. Kling lipsync bills in
+        // 5-second increments (a 7s clip is billed as 10s).
         if (modelKey === "kling-avatar") {
             const perSecond = modelConfig?.cost?.perMode?.[mode]?.perSecond
                 ?? modelConfig?.cost?.perMode?.["std"]?.perSecond
                 ?? 0.014;
-            return (0, helpers_2.getCreditsFromCost)(perSecond * duration, applyFloor);
+            const billedSeconds = Math.ceil(duration / 5) * 5;
+            return (0, helpers_2.getCreditsFromCost)(perSecond * billedSeconds, applyFloor);
+        }
+        // v2.6 splits cost by audio/noAudio tier (audio is 2× upcharge).
+        if (modelKey === "kling-v2.6") {
+            const branch = audio ? modelConfig?.cost?.audio : modelConfig?.cost?.noAudio;
+            const cost = branch?.table?.[mode]?.[duration];
+            if (cost === undefined || cost === null) {
+                logger_1.logger.warn(`Kling getCreditUsed: no v2.6 cost entry for mode="${mode}" duration=${duration} audio=${audio} — returning fallback`, { modelKey, mode, duration, audio });
+                return (0, helpers_2.getCreditsFromCost)(1.0, applyFloor);
+            }
+            return (0, helpers_2.getCreditsFromCost)(cost, applyFloor);
         }
         const cost = modelConfig?.cost?.table?.[mode]?.[duration];
         if (cost === undefined || cost === null) {

package/lib/services/aiGen/providers/kling/klingImage.service.d.ts

@@ -0,0 +1,21 @@
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import { CreditUsageParams, ImageGenerationParams, ImageGenerationResult } from "../types";
+export declare class KlingImageService extends BaseAiGenProviderService {
+    private readonly baseUrl;
+    private readonly submitTimeout;
+    private readonly pollTimeout;
+    private readonly maxPollMs;
+    private readonly pollIntervalMs;
+    private readonly v4HttpAgent;
+    private readonly v4HttpsAgent;
+    constructor();
+    private encodeJwtToken;
+    private request;
+    private submitOmniImageTask;
+    private submitStandardImageTask;
+    private pollUntilDone;
+    private uploadToStorage;
+    generateImage(params: ImageGenerationParams): Promise<ImageGenerationResult>;
+    getCreditUsed({ modelKey, numImages, multiClip }: CreditUsageParams): number;
+}
+//# sourceMappingURL=klingImage.service.d.ts.map

package/lib/services/aiGen/providers/kling/klingImage.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"klingImage.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/kling/klingImage.service.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AA2C3F,qBAAa,iBAAkB,SAAQ,wBAAwB;IAC7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAE/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IAExC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IAEtC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IAErC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAGxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkD;IAC9E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmD;;IAWhF,OAAO,CAAC,cAAc;YAUR,OAAO;YA6BP,mBAAmB;YAsCnB,uBAAuB;YAmCvB,aAAa;YA+Bb,eAAe;IAmBvB,aAAa,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAuClF,aAAa,CAAC,EAAE,QAAQ,EAAE,SAAa,EAAE,SAAiB,EAAE,EAAE,iBAAiB,GAAG,MAAM;CASzF"}