nmr-processing 9.5.1 → 9.5.2-pre.1685982544

package/src/xyz/util/fft2d/fftIndirectDimension.ts

@@ -0,0 +1,123 @@
+import { DoubleArray } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+import {
+  reimAbsolute,
+  reimAutoPhaseCorrection,
+  reimFFT,
+  reimPhaseCorrection,
+} from 'ml-spectra-processing';
+
+import {
+  apodization,
+  ApodizationFilterOptions,
+} from '../../../apodization/apodization';
+
+import { zeroFilling, ZeroFillingOptions } from './zeroFilling';
+
+interface PhaseCorrection {
+  mode?: string;
+  ph0?: number;
+  ph1?: number;
+}
+
+export interface IndirectDimensionOptions {
+  fnMode?: string;
+  zeroFilling?: ZeroFillingOptions;
+  apodization?: ApodizationFilterOptions;
+  phaseCorrection?: PhaseCorrection;
+}
+
+export function fftIndirectDimension(
+  data: { re: DoubleArray[] | Matrix; im: DoubleArray[] | Matrix },
+  options: IndirectDimensionOptions,
+) {
+  const reData = Matrix.checkMatrix(data.re);
+  const imData = Matrix.checkMatrix(data.im);
+
+  const nbRows = reData.rows;
+  const nbColumns = reData.columns;
+
+  const { zeroFilling: zeroFillingF1 } = options;
+  const { factor: f1Factor = 2 } = zeroFillingF1 || {};
+  const nbPointsF1 =
+    zeroFillingF1?.nbPoints || 2 ** Math.round(Math.log2(nbRows * f1Factor));
+  const { apodization: apodizationF1 } = options;
+  let {
+    ph0: ph0F1,
+    ph1: ph1F1,
+    mode: pcModeF1,
+  } = options.phaseCorrection || {};
+
+  const reResult = new Matrix(nbPointsF1, nbColumns);
+  const imResult = new Matrix(nbPointsF1, nbColumns);
+  for (let i = 0; i < nbColumns; i++) {
+    const { re: aRe, im: aIm } = apodization(
+      {
+        re: reData.getColumn(i),
+        im: imData.getColumn(i),
+      },
+      apodizationF1,
+    );
+
+    const newRe = [];
+    const newIm = [];
+    if (options.fnMode === 'echo') {
+      for (let j = 0; j < aRe.length; j += 2) {
+        newRe.push(aRe[j]);
+        newIm.push(aRe[j + 1]);
+      }
+    } else {
+      for (let j = 0; j < aRe.length; j++) {
+        newRe.push(aRe[j]);
+        newIm.push(-aIm[j]);
+      }
+    }
+
+    let transformed = reimFFT(
+      zeroFilling(
+        {
+          re: newRe,
+          im: newIm,
+        },
+        { digitalFilterValue: 0, nbPoints: nbPointsF1 },
+      ),
+      { applyZeroShift: true },
+    );
+    let { re, im } = transformed;
+
+    if (options.phaseCorrection?.mode === 'mc') {
+      re = reimAbsolute({ re, im });
+      im = new Float64Array(im.length);
+    }
+
+    if (pcModeF1 === 'pk') {
+      if (i === 0 && ph0F1 === undefined && ph1F1 === undefined) {
+        //here we can improve it by checking if the experiment is phase sensitive.
+        const phased = reimAutoPhaseCorrection(
+          { re, im },
+          { magnitudeMode: false },
+        );
+        ph0F1 = phased.ph0;
+        ph1F1 = phased.ph1;
+      }
+      if (ph0F1 !== undefined && ph1F1 !== undefined) {
+        Object.assign(
+          transformed,
+          reimPhaseCorrection(
+            transformed,
+            (ph0F1 * Math.PI) / 180,
+            (ph1F1 * Math.PI) / 180,
+          ),
+        );
+      }
+    }
+
+    reResult.setColumn(i, re);
+    imResult.setColumn(i, im);
+  }
+
+  return {
+    re: reResult,
+    im: imResult,
+  };
+}

package/src/xyz/util/fft2d/removeDCOffset.ts

@@ -0,0 +1,19 @@
+import { DataReIm, xMean } from 'ml-spectra-processing';
+
+export function removeDCOffset(data: DataReIm, options: any) {
+  let { digitalFilterValue = 0 } = options;
+  const nbPoints = data.re.length;
+  const newRe = new Float64Array(data.re);
+  const newIm = new Float64Array(data.im);
+  const averageRe = xMean(
+    data.re.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilterValue),
+  );
+  const averageIm = xMean(
+    data.im.slice((nbPoints * 0.75) >> 0, nbPoints - digitalFilterValue),
+  );
+  for (let i = digitalFilterValue; i < nbPoints - digitalFilterValue; i++) {
+    newRe[i] -= averageRe;
+    newIm[i] -= averageIm;
+  }
+  return { re: newRe, im: newIm };
+}

package/src/xyz/util/fft2d/zeroFilling.ts

@@ -0,0 +1,39 @@
+import { DataReIm } from 'ml-spectra-processing';
+
+export interface ZeroFillingOptions {
+  nbPoints?: number;
+  factor?: number;
+  digitalFilterValue?: number;
+}
+
+export function zeroFilling(data: DataReIm, options: ZeroFillingOptions) {
+  let { nbPoints, factor = 2, digitalFilterValue: grpdly = 0 } = options;
+
+  if (!nbPoints) {
+    nbPoints = 2 ** Math.round(Math.log2(data.re.length * factor));
+  }
+
+  let pointsToShift;
+  if (grpdly > 0) {
+    pointsToShift = Math.floor(grpdly);
+  } else {
+    pointsToShift = 0;
+  }
+
+  const { re, im } = data;
+
+  let newRE = new Float64Array(nbPoints);
+  let newIM = new Float64Array(nbPoints);
+
+  const length = Math.min(nbPoints, re.length);
+
+  newRE.set(re.slice(0, length - pointsToShift));
+  newIM.set(im.slice(0, length - pointsToShift));
+
+  if (pointsToShift > 0 && pointsToShift < nbPoints) {
+    newRE.set(re.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+    newIM.set(im.slice(re.length - pointsToShift), nbPoints - pointsToShift);
+  }
+
+  return { re: newRE, im: newIM };
+}

package/src/xyz/util/padData.ts

@@ -1,8 +1,9 @@
-import Matrix from 'ml-matrix';
+import { MinMaxContent } from 'cheminfo-types';
 
-import { Data2D } from '../Data2D';
-
-export function padData(spectraData: Data2D, options: { width: number }) {
+export function padData(
+  spectraData: MinMaxContent,
+  options: { width: number },
+) {
   let { minX, maxX, minY, maxY } = spectraData;
 
   const width = options.width;
@@ -20,15 +21,20 @@ export function padData(spectraData: Data2D, options: { width: number }) {
 
   let xOffset = xDiff / 2;
   let yOffset = yDiff / 2;
-  let newMatrix = Matrix.zeros(nbSubSpectra + yDiff, nbPoints + xDiff);
+
+  const newMatrix: Float64Array[] = [];
+  for (let i = 0; i < nbSubSpectra + yDiff; i++) {
+    newMatrix.push(new Float64Array(nbPoints + xDiff));
+  }
   for (let i = 0; i < nbSubSpectra; i++) {
     for (let j = 0; j < nbPoints; j++) {
-      newMatrix.set(i + yOffset, j + xOffset, spectraData.z[i][j]);
+      newMatrix[i + yOffset].set(spectraData.z[i], xOffset);
     }
   }
 
   return {
-    z: newMatrix.to2DArray(),
+    ...spectraData,
+    z: newMatrix,
     minX: minX - xOffset * xInterval,
     maxX: maxX + xOffset * xInterval,
     minY: minY - yOffset * yInterval,

package/src/xyz/xyzAutoSignalsPicking.ts

@@ -1,4 +1,5 @@
 import { v4 as generateID } from '@lukeed/uuid';
+import { MinMaxContent } from 'cheminfo-types';
 import * as convolution from 'ml-matrix-convolution';
 import * as matrixPeakFinders from 'ml-matrix-peaks-finder';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
@@ -11,7 +12,6 @@ import type { GetKernelOptions } from '../peaks/util/getKernel';
 import * as PeakOptimizer from '../peaks/util/peakOptimizer';
 import { MakeMandatory } from '../utilities/MakeMandatory';
 
-import { Data2D } from './Data2D';
 import type { NMRSignal2D } from './NMRSignal2D';
 import { padData } from './util/padData';
 
@@ -89,7 +89,7 @@ export type NMRSignal2DWithID<T extends Peak2D = Peak2D> = MakeMandatory<
 >;
 
 export function xyzAutoSignalsPicking(
-  spectraData: Data2D,
+  spectraData: MinMaxContent,
   options: XYZAutoSignalsPickingOptions,
 ) {
   let {

package/src/xyz/xyzAutoZonesPicking.ts

@@ -1,3 +1,5 @@
+import { MinMaxContent } from 'cheminfo-types';
+
 import { xyzAutoSignalsPicking } from '..';
 import type { GetKernelOptions } from '../peaks/util/getKernel';
 import { MakeMandatory } from '../utilities/MakeMandatory';
@@ -5,14 +7,6 @@ import { MakeMandatory } from '../utilities/MakeMandatory';
 import { NMRZone } from './NMRZone';
 import { formatZones } from './util/formatZone';
 
-export interface Data2D {
-  z: number[][] | Float64Array[];
-  minX: number;
-  maxX: number;
-  minY: number;
-  maxY: number;
-}
-
 export interface XYZAutoZonesPickingOptions {
   /**
    * max number of points in any dimension to pad the input data, this is needed to avoid lost peaks when the input matrix is too small.
@@ -71,7 +65,7 @@ export interface XYZAutoZonesPickingOptions {
 export type NMRZoneWithID = MakeMandatory<NMRZone, 'id'>;
 
 export function xyzAutoZonesPicking(
-  spectraData: Data2D,
+  spectraData: MinMaxContent,
   options: XYZAutoZonesPickingOptions,
 ): NMRZoneWithID[] {
   const signals = xyzAutoSignalsPicking(spectraData, options);

package/src/xyz/xyzBidimensionalFFT.ts

@@ -0,0 +1,122 @@
+import { Data2D, DoubleArray, Data2DFid } from 'cheminfo-types';
+import Matrix from 'ml-matrix';
+
+import { ApodizationFilterOptions } from '../apodization/apodization';
+
+import { quadrature } from './quadrature';
+import {
+  DirectDimensionOptions,
+  fftDirectDimension,
+} from './util/fft2d/fftDirectDimension';
+import {
+  fftIndirectDimension,
+  IndirectDimensionOptions,
+} from './util/fft2d/fftIndirectDimension';
+import { ZeroFillingOptions } from './util/fft2d/zeroFilling';
+
+type Info2D = any;
+
+interface BidimensionalFFTOptions {
+  fnMode: string;
+  info: Info2D;
+  zeroFilling?: ZeroFillingOptions;
+  phaseCorrection?: { ph0: number; ph1: number };
+  digitalFilterValue?: number;
+  apodization?: ApodizationFilterOptions;
+  indirect?: IndirectDimensionOptions;
+  direct?: DirectDimensionOptions;
+}
+
+export function xyzBidimensionalFFT(
+  data: Data2D,
+  options: BidimensionalFFTOptions,
+) {
+  ensureData2DFid(data);
+
+  const {
+    info,
+    fnMode,
+    digitalFilterValue = 0,
+    zeroFilling: zeroFillingGeneral,
+  } = options;
+
+  const orderedData = quadrature(data, { fnMode });
+
+  const { re: reData } = orderedData;
+  const nbRows = reData.length;
+  const nbColumns = reData[0].length;
+  const { direct = {}, indirect = {} } = options;
+
+  const { zeroFilling: zeroFillingF2 = zeroFillingGeneral } = direct;
+
+  const { factor: f2Factor = 2 } = zeroFillingF2 || {};
+  const nbPointsF2 =
+    zeroFillingF2?.nbPoints || 2 ** Math.round(Math.log2(nbColumns * f2Factor));
+
+  const transformed = fftDirectDimension(orderedData, {
+    ...direct,
+    fnMode,
+    digitalFilterValue,
+    zeroFilling: { nbPoints: nbPointsF2 },
+  });
+
+  const { zeroFilling: zeroFillingF1 } = options;
+  const { factor: f1Factor = 2 } = zeroFillingF1 || {};
+  const nbPointsF1 =
+    zeroFillingF1?.nbPoints || 2 ** Math.round(Math.log2(nbRows * f1Factor));
+  const { re: reResult, im: imResult } = fftIndirectDimension(transformed, {
+    ...indirect,
+    fnMode,
+    zeroFilling: { nbPoints: nbPointsF1 },
+  });
+
+  const minMaxXY = getMinMaxXY(info);
+  return {
+    re: {
+      z: convertToDoubleArray(reResult),
+      maxZ: reResult.max(),
+      minZ: reResult.min(),
+      ...minMaxXY,
+    },
+    im: {
+      z: convertToDoubleArray(imResult),
+      maxZ: imResult.max(),
+      minZ: imResult.min(),
+      ...minMaxXY,
+    },
+  };
+}
+
+function ensureData2DFid(data: Data2D): asserts data is Data2DFid {
+  if (!('re' in data)) {
+    throw new Error('bidimensional FFT only can be applied to raw data');
+  }
+}
+
+function convertToDoubleArray(data: Matrix) {
+  const result: DoubleArray[] = new Array(data.rows);
+  for (let i = 0; i < data.rows; i++) {
+    result[i] = new Float64Array(data.getRow(i));
+  }
+  return result;
+}
+
+function getMinMaxXY(info: Info2D) {
+  const min: number[] = [];
+  const max: number[] = [];
+  for (let i = 0; i < info.baseFrequency.length; i++) {
+    const baseFrequency = Number.parseFloat(info.baseFrequency[i]);
+    const frequencyOffset = Number.parseFloat(info.frequencyOffset[i]);
+    const spectralWidth = Number.parseFloat(info.spectralWidth[i]);
+    const offset = frequencyOffset / baseFrequency;
+    min.push(offset - spectralWidth * 0.5);
+    max.push(offset + spectralWidth * 0.5);
+  }
+
+  return {
+    minX: min[0],
+    maxX: max[0],
+    minY: min[1],
+    maxY: max[1],
+  };
+}

package/src/xyz/xyzJResAnalyzer.ts

@@ -1,9 +1,15 @@
 import { v4 as generateID } from '@lukeed/uuid';
+import { PeakXYWidth } from 'cheminfo-types';
 import type { Peak2D } from 'ml-matrix-peaks-finder';
 import simpleClustering from 'ml-simple-clustering';
 
 import { addMissingIDs } from '../peaks/util/addMissingIDs';
-import type { JAxisKeys } from '../signals/utils/jAnalyzer';
+import type {
+  JAxisKeys,
+  Peak1DIntern,
+  SignalFlexiblePeaks,
+  SignalIntern,
+} from '../signals/utils/jAnalyzer';
 import jAnalyzer from '../signals/utils/jAnalyzer';
 import type { MakeMandatory } from '../utilities/MakeMandatory';
 
@@ -40,20 +46,14 @@ interface XYZJResAnalyzerOptions extends CompilePatternOptions {
 interface Peak2DInternalCompiler extends Peak2D {
   width?: number;
 }
-type Signal2DInternalCompiler = Omit<NMRSignal2D, 'peaks'> & {
-  peaks: Peak2DInternalCompiler[];
-  integralData: { from: number; to: number };
-  nbPeaks: number;
-  multiplicity: string;
-  pattern: string;
-  observe: number;
-};
 
 type CompilePatternOptionsMandatory = MakeMandatory<
   CompilePatternOptions,
   'observedFrequencies' | 'tolerances' | 'nuclei' | 'jAnalyzer'
 >;
 
+type Peak2DWidth = PeakXYWidth & { z: number };
+
 export function xyzJResAnalyzer(
   signals: NMRSignal2D[],
   options: XYZJResAnalyzerOptions = {},
@@ -76,7 +76,7 @@ export function xyzJResAnalyzer(
     jAnalyzer,
   });
   //check if the signal are symmetric around the reference
-  let signals2D = [];
+  let signals2D: any[] = [];
   for (const tempSignal of temporalSignals) {
     let delta = tempSignal.y.delta;
     if (Math.abs(delta - reference) > referenceMaxShiftError) continue;
@@ -108,43 +108,52 @@ function compilePattern(
   };
 
   const defaultWidth = 0.02 * observedFrequencies[0];
-  const newSignals = parse(stringify(signals));
+  const newSignals: SignalFlexiblePeaks[] = [];
   //adapt to 1D jAnalyzer
-  for (const signal of newSignals) {
-    let peaks = signal.peaks;
-    signal.nbPeaks = signal.peaks.length;
-    signal.multiplicity = '';
-    signal.pattern = '';
-    signal.delta1 = signal.shiftY;
-    signal.observe = observedFrequencies[1];
-    signal.integralData = {
-      from: Number.MAX_SAFE_INTEGER,
-      to: Number.MIN_SAFE_INTEGER,
-    };
-    for (const peak of peaks) {
-      if (!peak.width) peak.width = defaultWidth;
+  for (const signal of signals) {
+    let peaks: Peak2DWidth[] = [];
+    for (const peak of signal.peaks || []) {
+      peaks.push({
+        ...peak,
+        width: defaultWidth,
+      });
     }
-    peaks.sort((a: Peak2D, b: Peak2D) => a.y - b.y);
+    peaks.sort((a, b) => a.y - b.y);
+    newSignals.push({
+      nbPeaks: peaks.length,
+      multiplicity: '',
+      pattern: '',
+      startX: peaks[0].y - defaultWidth,
+      stopX: peaks[peaks.length - 1].y + defaultWidth,
+      delta: signal.y.delta,
+      observe: observedFrequencies[1],
+      integralData: {
+        value: -1,
+        from: Number.MAX_SAFE_INTEGER,
+        to: Number.MIN_SAFE_INTEGER,
+      },
+      peaks,
+    });
   }
 
   for (let i = 0; i < signals.length; i++) {
-    jAnalyzer.compilePattern(newSignals[i], jAnalyzerOptions);
+    const signal = jAnalyzer.compilePattern(newSignals[i], jAnalyzerOptions);
 
     if (
-      newSignals[i].maskPattern &&
-      newSignals[i].multiplicity !== 'm' &&
-      newSignals[i].multiplicity !== ''
+      signal.maskPattern &&
+      signal.multiplicity !== 'm' &&
+      signal.multiplicity !== ''
     ) {
       // Create a new signal with the removed peaks
-      let peaksO = [];
-      for (let j = newSignals[i].maskPattern.length - 1; j >= 0; j--) {
-        if (newSignals[i].maskPattern[j] === false) {
-          let peakR = newSignals[i].peaks.splice(j, 1)[0];
+      let peaksO: Peak1DIntern[] = [];
+      for (let j = signal.maskPattern.length - 1; j >= 0; j--) {
+        if (!signal.maskPattern[j]) {
+          let peakR = signal.peaks.splice(j, 1)[0];
           peaksO.push(peakR);
-          newSignals[i].mask.splice(j, 1);
-          newSignals[i].mask2.splice(j, 1);
-          newSignals[i].maskPattern.splice(j, 1);
-          newSignals[i].nbPeaks--;
+          signal.mask.splice(j, 1);
+          signal.mask2?.splice(j, 1);
+          signal.maskPattern.splice(j, 1);
+          signal.nbPeaks--;
         }
       }
       if (peaksO.length > 0) {
@@ -165,7 +174,7 @@ function compilePattern(
   return signals;
 }
 
-function createSignals2D(peaksInput: Peak2D[], options: any) {
+function createSignals2D(peaksInput: Peak1DIntern[], options: any) {
   let { observedFrequencies, tolerances, nuclei, dx, dy } = options;
 
   const peaks: Peak2DInternalCompiler[] = parse(stringify(peaksInput));
@@ -176,7 +185,7 @@ function createSignals2D(peaksInput: Peak2D[], options: any) {
 
   // The connectivity matrix is an square and symmetric matrix, so we'll only store the upper diagonal in an
   // array like form
-  let connectivity = [];
+  let connectivity: Array<0 | 1> = [];
   for (let i = 0; i < peaks.length; i++) {
     for (let j = i; j < peaks.length; j++) {
       if (
@@ -192,7 +201,7 @@ function createSignals2D(peaksInput: Peak2D[], options: any) {
   }
   let clusters = simpleClustering(connectivity);
 
-  let signals = [];
+  let signals: SignalIntern[] = [];
   if (clusters) {
     for (let cluster of clusters) {
       let signal: any = {
@@ -212,7 +221,7 @@ function createSignals2D(peaksInput: Peak2D[], options: any) {
         shiftX: 0,
         shiftY: 0,
       };
-      let peaks2D = [];
+      let peaks2D: Peak2DInternalCompiler[] = [];
       let minMax1 = [Number.MAX_VALUE, 0];
       let minMax2 = [Number.MAX_VALUE, 0];
       let sumZ = 0;
@@ -247,7 +256,7 @@ function createSignals2D(peaksInput: Peak2D[], options: any) {
       signal.shiftY /= sumZ;
       signal.delta1 = signal.shiftY;
       signal.peaks = peaks2D;
-      signals.push(signal as Signal2DInternalCompiler);
+      signals.push(signal);
     }
   }
   return signals;

package/lib/prediction/utils/flatGroupedDiaIDs.d.ts

@@ -1,2 +0,0 @@
-import type { GroupedDiastereotopicAtomIDs } from 'openchemlib-utils';
-export declare function flatGroupedDiaIDs(groups: GroupedDiastereotopicAtomIDs): string[];

package/lib/prediction/utils/flatGroupedDiaIDs.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatGroupedDiaIDs = void 0;
-function flatGroupedDiaIDs(groups) {
-    let diaIDs = [];
-    for (let group of groups) {
-        for (let atom of group.atoms) {
-            diaIDs[atom] = group.oclID;
-        }
-    }
-    return diaIDs;
-}
-exports.flatGroupedDiaIDs = flatGroupedDiaIDs;
-//# sourceMappingURL=flatGroupedDiaIDs.js.map

package/lib/prediction/utils/flatGroupedDiaIDs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flatGroupedDiaIDs.js","sourceRoot":"","sources":["../../../src/prediction/utils/flatGroupedDiaIDs.ts"],"names":[],"mappings":";;;AAEA,SAAgB,iBAAiB,CAAC,MAAoC;IACpE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,KAAK,IAAI,MAAM,EAAE;QACxB,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE;YAC5B,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;SAC5B;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AARD,8CAQC"}

package/lib/xyz/Data2D.d.ts

@@ -1,7 +0,0 @@
-export interface Data2D {
-    z: number[][] | Float64Array[];
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: number;
-}

package/lib-esm/prediction/utils/flatGroupedDiaIDs.js

@@ -1,10 +0,0 @@
-export function flatGroupedDiaIDs(groups) {
-    let diaIDs = [];
-    for (let group of groups) {
-        for (let atom of group.atoms) {
-            diaIDs[atom] = group.oclID;
-        }
-    }
-    return diaIDs;
-}
-//# sourceMappingURL=flatGroupedDiaIDs.js.map

package/lib-esm/prediction/utils/flatGroupedDiaIDs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flatGroupedDiaIDs.js","sourceRoot":"","sources":["../../../src/prediction/utils/flatGroupedDiaIDs.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,iBAAiB,CAAC,MAAoC;IACpE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,KAAK,IAAI,MAAM,EAAE;QACxB,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,KAAK,EAAE;YAC5B,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;SAC5B;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}