@loaders.gl/netcdf 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/netcdfjs/netcdf-reader.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetCDFReader = void 0;
+const iobuffer_1 = require("../iobuffer/iobuffer");
+const read_header_1 = require("./read-header");
+const read_data_1 = require("./read-data");
+/**
+ * Reads a NetCDF v3.x file
+ * https://www.unidata.ucar.edu/software/netcdf/docs/file_format_specifications.html
+ * @param {ArrayBuffer} data - ArrayBuffer or any Typed Array (including Node.js' Buffer from v4) with the data
+ * @constructor
+ */
+class NetCDFReader {
+    constructor(data) {
+        const buffer = new iobuffer_1.IOBuffer(data);
+        buffer.setBigEndian();
+        // Validate that it's a NetCDF file
+        const magic = buffer.readChars(3);
+        if (magic !== 'CDF') {
+            throw new Error(`NetCDF: file should start with 'CDF', found ${magic}`);
+        }
+        // Check the NetCDF format
+        const version = buffer.readByte();
+        if (version > 2) {
+            throw new Error(`NetCDF: unsupported version ${version}`);
+        }
+        // Read the header
+        this.header = (0, read_header_1.readNetCDFHeader)(buffer, version);
+        this.buffer = buffer;
+    }
+    /**
+     * @return {string} - Version for the NetCDF format
+     */
+    get version() {
+        if (this.header.version === 1) {
+            return 'classic format';
+        }
+        return '64-bit offset format';
+    }
+    /**
+     * Get metadata for the record dimension
+     */
+    get recordDimension() {
+        return this.header.recordDimension;
+    }
+    /**
+     * Get list of dimensions (each with `name` and `size`)
+     */
+    get dimensions() {
+        return this.header.dimensions;
+    }
+    /**
+     * Get list of global attributes with:
+     *  * `name`: String with the name of the attribute
+     *  * `type`: String with the type of the attribute
+     *  * `value`: A number or string with the value of the attribute
+     */
+    get attributes() {
+        return this.header.attributes;
+    }
+    /**
+     * Get list of variables
+     */
+    get variables() {
+        return this.header.variables;
+    }
+    /**
+     * Check if an attribute exists
+     * @param attributeName - Name of the attribute to find
+     * @return
+     */
+    attributeExists(attributeName) {
+        const attribute = this.attributes.find((val) => val.name === attributeName);
+        return attribute !== undefined;
+    }
+    /**
+     * Returns the value of an attribute
+     * @param attributeName
+     * @return Value of the attributeName or null
+     */
+    getAttribute(attributeName) {
+        const attribute = this.attributes.find((val) => val.name === attributeName);
+        if (attribute)
+            return attribute.value;
+        return null;
+    }
+    /**
+     * Check if a dataVariable exists
+     * @param variableName - Name of the variable to find
+     * @return
+     */
+    dataVariableExists(variableName) {
+        const variable = this.header.variables.find(function (val) {
+            return val.name === variableName;
+        });
+        return variable !== undefined;
+    }
+    /**
+     * Returns the value of a variable as a string
+     * @param variableName
+     * @return Value of the variable as a string or null
+     */
+    getDataVariableAsString(variableName) {
+        const variable = this.getDataVariable(variableName);
+        if (variable)
+            return variable.join('');
+        return null;
+    }
+    /**
+     * Retrieves the data for a given variable
+     * @param variableName - Name of the variable to search or variable object
+     * @return List with the variable values
+     */
+    getDataVariable(variableName) {
+        let variable;
+        if (typeof variableName === 'string') {
+            // search the variable
+            variable = this.header.variables.find(function (val) {
+                return val.name === variableName;
+            });
+        }
+        else {
+            variable = variableName;
+        }
+        // throws if variable not found
+        if (variable === undefined) {
+            throw new Error(`NetCDF: variable not found: ${variableName}`);
+        }
+        // go to the offset position
+        this.buffer.seek(variable.offset);
+        if (variable.record) {
+            // record variable case
+            return (0, read_data_1.readRecord)(this.buffer, variable, this.header.recordDimension);
+        }
+        // non-record variable case
+        return (0, read_data_1.readNonRecord)(this.buffer, variable);
+    }
+    toString() {
+        const result = [];
+        result.push('DIMENSIONS');
+        for (const dimension of this.dimensions) {
+            result.push(`  ${dimension.name.padEnd(30)} = size: ${dimension.size}`);
+        }
+        result.push('');
+        result.push('GLOBAL ATTRIBUTES');
+        for (const attribute of this.attributes) {
+            result.push(`  ${attribute.name.padEnd(30)} = ${attribute.value}`);
+        }
+        const variables = JSON.parse(JSON.stringify(this.variables));
+        result.push('');
+        result.push('VARIABLES:');
+        for (const variable of variables) {
+            variable.value = this.getDataVariable(variable);
+            let stringify = JSON.stringify(variable.value);
+            if (stringify.length > 50)
+                stringify = stringify.substring(0, 50);
+            if (!isNaN(variable.value.length)) {
+                stringify += ` (length: ${variable.value.length})`;
+            }
+            result.push(`  ${variable.name.padEnd(30)} = ${stringify}`);
+        }
+        return result.join('\n');
+    }
+}
+exports.NetCDFReader = NetCDFReader;

package/dist/netcdfjs/netcdf-types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Header describing a NetDCF file
+ * @param recordDimension: Number with the length of record dimension
+ * @param dimensions: List of dimensions
+ * @param attributes: List of global attributes
+ * @param variables: List of variables
+ */
+export declare type NetCDFHeader = {
+    version: number;
+    recordDimension: NetCDFRecordDimension;
+    dimensions: NetCDFDimension[];
+    attributes: NetCDFAttribute[];
+    variables: NetCDFVariable[];
+};
+/**
+ * Metadata for the record dimension
+ * @param length Number of elements in the record dimension
+ * @param id Id in the list of dimensions for the record dimension
+ * @param name  name of the record dimension
+ * @param recordStep the record variables step size
+ */
+export declare type NetCDFRecordDimension = {
+    length: number;
+    id: number;
+    name: string;
+    recordStep: number;
+};
+/**
+ * `dimensions` is an array of dimension objects:
+ * @param name name of the dimension
+ * @param size size of the dimension
+ * @param recordId: id of the dimension that has unlimited size or undefined,
+ * @param recordName: name of the dimension that has unlimited size
+ */
+export declare type NetCDFDimension = {
+    name: string;
+    size: number;
+    recordId: number;
+    recordName: string;
+};
+/**
+ * Number of recordStep and list of variables with:
+ * @param name String with the name of the variable
+ * @param dimensions Array with the dimension IDs of the variable
+ * @param attributes Array with the attributes of the variable
+ * @param type String with the type of the variable
+ * @param size Number with the size of the variable
+ * @param offset Number with the offset where of the variable begins
+ * @param record True if is a record variable, false otherwise (unlimited size)
+ */
+export declare type NetCDFVariable = {
+    name: string;
+    dimensions: [];
+    attributes: [];
+    type: string;
+    size: number;
+    offset: number;
+    record: boolean;
+};
+/**
+ * @param name name of the attribute
+ * @param type type of the attribute
+ * @param value number or string with the value of the attribute
+ */
+export declare type NetCDFAttribute = {
+    name: string;
+    type: string;
+    value: string;
+};
+//# sourceMappingURL=netcdf-types.d.ts.map

package/dist/netcdfjs/netcdf-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"netcdf-types.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/netcdf-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,oBAAY,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,qBAAqB,CAAC;IACvC,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,SAAS,EAAE,cAAc,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;;;GAMG;AACH,oBAAY,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;GAMG;AACH,oBAAY,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;GASG;AACH,oBAAY,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,EAAE,CAAC;IACf,UAAU,EAAE,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,oBAAY,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/netcdfjs/netcdf-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/netcdfjs/read-data.d.ts

@@ -0,0 +1,18 @@
+import type { IOBuffer } from '../iobuffer/iobuffer';
+import type { NetCDFRecordDimension, NetCDFVariable } from './netcdf-types';
+/**
+ * Read data for the given non-record variable
+ * @param buffer - Buffer for the file data
+ * @param variable - Variable metadata
+ * @return Data of the element
+ */
+export declare function readNonRecord(buffer: IOBuffer, variable: NetCDFVariable): (string | number | number[] | Uint8Array)[];
+/**
+ * Read data for the given record variable
+ * @param buffer - Buffer for the file data
+ * @param variable - Variable metadata
+ * @param recordDimension - Record dimension metadata
+ * @return - Data of the element
+ */
+export declare function readRecord(buffer: IOBuffer, variable: NetCDFVariable, recordDimension: NetCDFRecordDimension): (string | number | number[] | Uint8Array)[];
+//# sourceMappingURL=read-data.d.ts.map

package/dist/netcdfjs/read-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-data.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/read-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAC,qBAAqB,EAAE,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAK1E;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,QAAQ,EAChB,QAAQ,EAAE,cAAc,GACvB,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,CAAC,EAAE,CAc7C;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,QAAQ,EAChB,QAAQ,EAAE,cAAc,EACxB,eAAe,EAAE,qBAAqB,GACrC,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,CAAC,EAAE,CAoB7C"}

package/dist/netcdfjs/read-data.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRecord = exports.readNonRecord = void 0;
+const read_type_1 = require("./read-type");
+// const STREAMING = 4294967295;
+/**
+ * Read data for the given non-record variable
+ * @param buffer - Buffer for the file data
+ * @param variable - Variable metadata
+ * @return Data of the element
+ */
+function readNonRecord(buffer, variable) {
+    // variable type
+    const type = (0, read_type_1.str2num)(variable.type);
+    // size of the data
+    const size = variable.size / (0, read_type_1.num2bytes)(type);
+    // iterates over the data
+    const data = new Array(size);
+    for (let i = 0; i < size; i++) {
+        data[i] = (0, read_type_1.readType)(buffer, type, 1);
+    }
+    return data;
+}
+exports.readNonRecord = readNonRecord;
+/**
+ * Read data for the given record variable
+ * @param buffer - Buffer for the file data
+ * @param variable - Variable metadata
+ * @param recordDimension - Record dimension metadata
+ * @return - Data of the element
+ */
+function readRecord(buffer, variable, recordDimension) {
+    // variable type
+    const type = (0, read_type_1.str2num)(variable.type);
+    const width = variable.size ? variable.size / (0, read_type_1.num2bytes)(type) : 1;
+    // size of the data
+    // TODO streaming data
+    const size = recordDimension.length;
+    // iterates over the data
+    const data = new Array(size);
+    const step = recordDimension.recordStep;
+    for (let i = 0; i < size; i++) {
+        const currentOffset = buffer.offset;
+        data[i] = (0, read_type_1.readType)(buffer, type, width);
+        buffer.seek(currentOffset + step);
+    }
+    return data;
+}
+exports.readRecord = readRecord;

package/dist/netcdfjs/read-header.d.ts

@@ -0,0 +1,16 @@
+import type { IOBuffer } from '../iobuffer/iobuffer';
+import type { NetCDFHeader } from './netcdf-types';
+/**
+ * Read the header of the file
+ * @param buffer - Buffer for the file data
+ * @param version - Version of the file
+ * @return  - Header
+ */
+export declare function readNetCDFHeader(buffer: IOBuffer, version: number): NetCDFHeader;
+/**
+ * Reads the name
+ * @param buffer - Buffer for the file data
+ * @return Name
+ */
+export declare function readName(buffer: IOBuffer): string;
+//# sourceMappingURL=read-header.d.ts.map

package/dist/netcdfjs/read-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-header.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/read-header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAC,YAAY,EAAmD,MAAM,gBAAgB,CAAC;AAWnG;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,CA4BhF;AA2MD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAWjD"}

package/dist/netcdfjs/read-header.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readName = exports.readNetCDFHeader = void 0;
+const read_type_1 = require("./read-type");
+// Grammar constants
+const ZERO = 0;
+const NC_DIMENSION = 10;
+const NC_VARIABLE = 11;
+const NC_ATTRIBUTE = 12;
+const NC_UNLIMITED = 0;
+/**
+ * Read the header of the file
+ * @param buffer - Buffer for the file data
+ * @param version - Version of the file
+ * @return  - Header
+ */
+function readNetCDFHeader(buffer, version) {
+    // Length of record dimension
+    // sum of the varSize's of all the record variables.
+    const recordDimensionLength = buffer.readUint32();
+    // List of dimensions
+    const dimList = readDimensionsList(buffer);
+    // List of global attributes
+    const attributes = readAttributesList(buffer);
+    // List of variables
+    const variableList = readVariablesList(buffer, dimList.recordId, version);
+    const header = {
+        version,
+        recordDimension: {
+            length: recordDimensionLength,
+            id: dimList.recordId,
+            name: dimList.recordName,
+            recordStep: variableList.recordStep
+        },
+        dimensions: dimList.dimensions,
+        variables: variableList.variables,
+        attributes
+    };
+    return header;
+}
+exports.readNetCDFHeader = readNetCDFHeader;
+/**
+ * Read list of dimensions
+ * @ignore
+ * @param {IOBuffer} buffer - Buffer for the file data
+ */
+function readDimensionsList(buffer) {
+    const dimList = buffer.readUint32();
+    if (dimList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of dimensions');
+        }
+        // TODO - is this empty dimension list supported / recoverable?
+        return {
+            recordId: 0,
+            recordName: '',
+            dimensions: []
+        };
+    }
+    if (dimList !== NC_DIMENSION) {
+        throw new Error('NetCDF: wrong tag for list of dimensions');
+    }
+    // Length of dimensions
+    const dimensionSize = buffer.readUint32();
+    const dimensions = new Array(dimensionSize);
+    let recordId;
+    let recordName;
+    for (let dim = 0; dim < dimensionSize; dim++) {
+        // Read name
+        const name = readName(buffer);
+        // Read dimension size
+        const size = buffer.readUint32();
+        if (size === NC_UNLIMITED) {
+            // in netcdf 3 one field can be of size unlimmited
+            recordId = dim;
+            recordName = name;
+        }
+        dimensions[dim] = {
+            name,
+            size
+        };
+    }
+    return {
+        dimensions,
+        recordId,
+        recordName
+    };
+}
+/**
+ * List of attributes
+ * @ignore
+ * @param buffer - Buffer for the file data
+ * @return List of attributes with:
+ */
+function readAttributesList(buffer) {
+    const gAttList = buffer.readUint32();
+    if (gAttList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of attributes');
+        }
+        return [];
+    }
+    if (gAttList !== NC_ATTRIBUTE) {
+        throw new Error('NetCDF: wrong tag for list of attributes');
+    }
+    // Length of attributes
+    const attributeSize = buffer.readUint32();
+    const attributes = new Array(attributeSize);
+    for (let gAtt = 0; gAtt < attributeSize; gAtt++) {
+        // Read name
+        const name = readName(buffer);
+        // Read type
+        const type = buffer.readUint32();
+        if (type < 1 || type > 6) {
+            throw new Error(`NetCDF: non valid type ${type}`);
+        }
+        // Read attribute
+        const size = buffer.readUint32();
+        const value = (0, read_type_1.readType)(buffer, type, size);
+        // Apply padding
+        padding(buffer);
+        attributes[gAtt] = {
+            name,
+            type: (0, read_type_1.num2str)(type),
+            value
+        };
+    }
+    return attributes;
+}
+/**
+ * List of variables
+ * @param buffer - Buffer for the file data
+ * @param recordId - Id of the unlimited dimension (also called record dimension)
+ *                            This value may be undefined if there is no unlimited dimension
+ * @param {number} version - Version of the file
+ */
+// eslint-disable-next-line max-statements, complexity
+function readVariablesList(buffer, recordId, version) {
+    const varList = buffer.readUint32();
+    let recordStep = 0;
+    if (varList === ZERO) {
+        if (buffer.readUint32() !== ZERO) {
+            throw new Error('NetCDF: wrong empty tag for list of variables');
+        }
+        return {
+            recordStep,
+            variables: []
+        };
+    }
+    if (varList !== NC_VARIABLE) {
+        throw new Error('NetCDF: wrong tag for list of variables');
+    }
+    // Length of variables
+    const variableSize = buffer.readUint32();
+    const variables = new Array(variableSize);
+    for (let v = 0; v < variableSize; v++) {
+        // Read name
+        const name = readName(buffer);
+        // Read dimensionality of the variable
+        const dimensionality = buffer.readUint32();
+        // Index into the list of dimensions
+        const dimensionsIds = new Array(dimensionality);
+        for (let dim = 0; dim < dimensionality; dim++) {
+            dimensionsIds[dim] = buffer.readUint32();
+        }
+        // Read variables size
+        const attributes = readAttributesList(buffer);
+        // Read type
+        const type = buffer.readUint32();
+        if (type < 1 && type > 6) {
+            throw new Error(`NetCDF: non valid type ${type}`);
+        }
+        // Read variable size
+        // The 32-bit varSize field is not large enough to contain the size of variables that require
+        // more than 2^32 - 4 bytes, so 2^32 - 1 is used in the varSize field for such variables.
+        const varSize = buffer.readUint32();
+        // Read offset
+        let offset = buffer.readUint32();
+        if (version === 2) {
+            if (offset > 0) {
+                throw new Error('NetCDF: offsets larger than 4GB not supported');
+            }
+            offset = buffer.readUint32();
+        }
+        let record = false;
+        // Count amount of record variables
+        if (typeof recordId !== 'undefined' && dimensionsIds[0] === recordId) {
+            recordStep += varSize;
+            record = true;
+        }
+        variables[v] = {
+            name,
+            dimensions: dimensionsIds,
+            attributes,
+            type: (0, read_type_1.num2str)(type),
+            size: varSize,
+            offset,
+            record
+        };
+    }
+    return {
+        variables,
+        recordStep
+    };
+}
+// HELPERS
+/**
+ * Reads the name
+ * @param buffer - Buffer for the file data
+ * @return Name
+ */
+function readName(buffer) {
+    // Read name
+    const nameLength = buffer.readUint32();
+    const name = buffer.readChars(nameLength);
+    // validate name
+    // TODO
+    // Apply padding
+    padding(buffer);
+    return name;
+}
+exports.readName = readName;
+/**
+ * Moves 1, 2, or 3 bytes to next 4-byte boundary
+ */
+function padding(buffer) {
+    if (buffer.offset % 4 !== 0) {
+        buffer.skip(4 - (buffer.offset % 4));
+    }
+}

package/dist/netcdfjs/read-type.d.ts

@@ -0,0 +1,36 @@
+import { IOBuffer } from '../iobuffer/iobuffer';
+export declare const TYPES: {
+    BYTE: number;
+    CHAR: number;
+    SHORT: number;
+    INT: number;
+    FLOAT: number;
+    DOUBLE: number;
+};
+/**
+ * Given a type and a size reads the next element
+ * @param buffer - Buffer for the file data
+ * @param type - Type of the data to read
+ * @param size - Size of the element to read
+ * @return
+ */
+export declare function readType(buffer: IOBuffer, type: number, size: number): string | number | number[] | Uint8Array;
+/**
+ * Parse a number into their respective type
+ * @param type - integer that represents the type
+ * @return parsed value of the type
+ */
+export declare function num2str(type: number): string;
+/**
+ * Parse a number type identifier to his size in bytes
+ * @param type - integer that represents the type
+ * @return size of the type
+ */
+export declare function num2bytes(type: number): number;
+/**
+ * Reverse search of num2str
+ * @param type string that represents the type
+ * @return parsed value of the type
+ */
+export declare function str2num(type: string): number;
+//# sourceMappingURL=read-type.d.ts.map

package/dist/netcdfjs/read-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-type.d.ts","sourceRoot":"","sources":["../../src/netcdfjs/read-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAE9C,eAAO,MAAM,KAAK;;;;;;;CAOjB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,CAkBzC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB9C;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkB5C"}