Directory: 有序結(jié)構數(shù)組
  ├── Container:Item (主圖片 - 必須是第一項)
  ├── Container:Item (增益圖 - Ultra HDR時)
  └── Container:Item (視頻文件 - 必須是最后一項)

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/Blk_12"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <hy.sohu.com.app.ugc.share.view.widget.MotionPhotoView
        android:id="@+id/motion_photo_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

<x:xmpmeta xmlns:x="adobe:ns:meta/">
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
        <rdf:Description rdf:about=""
            xmlns:Camera="http://ns.google.com/photos/1.0/camera/"
            xmlns:Container="http://ns.google.com/photos/1.0/container/">

            
            <Camera:MotionPhoto>1</Camera:MotionPhoto>
            <Camera:MotionPhotoVersion>1</Camera:MotionPhotoVersion>
            <Camera:MotionPhotoPresentationTimestampUs>1500000</Camera:MotionPhotoPresentationTimestampUs>

            
            <Container:Directory>
                <rdf:Seq>
                    <rdf:li rdf:parseType="Resource">
                        <Container:Item:Mime>image/jpeg</Container:Item:Mime>
                        <Container:Item:Semantic>Primary</Container:Item:Semantic>
                    </rdf:li>
                </rdf:Seq>
            </Container:Directory>
        </rdf:Description>
    </rdf:RDF>
</x:xmpmeta>

^([^\\s\\/\\\\][^\\/\\\\]*MP)\\.(JPG|jpg|JPEG|jpeg|HEIC|heic|AVIF|avif)

exiftool /Users/allenzhang/Downloads/1752549853110.jpg

File Name                       : 1752549853110.jpg
File Size                       : 5.5 MB
Make                            : (小米手機型號)
XMP Toolkit                     : Adobe XMP Core 5.1.0-jc003
Micro Video Version             : 1
Micro Video                     : 1
Micro Video Offset              : 1735850
Micro Video Presentation Timestamp Us: 761955
Image Width                     : 3072
Image Height                    : 4096

ROOT NODE
 http://ns.google.com/photos/1.0/camera/ = "GCamera:" (0x80000000 : SCHEMA_NODE)
  GCamera:MicroVideo = "1"
  GCamera:MicroVideoVersion = "1"
  GCamera:MicroVideoOffset = "1757635"
  GCamera:MicroVideoPresentationTimestampUs = "333227"
 http://ns.adobe.com/exif/1.0/ = "exif:" (0x80000000 : SCHEMA_NODE)
  exif:ImageWidth = "4096"
  exif:ImageLength = "3072"
  exif:Make = "Xiaomi"
  exif:Model = "XIAOMI Device"
 http://ns.adobe.com/xmp/note/ = "xmpNote:" (0x80000000 : SCHEMA_NODE)
  xmpNote:HasExtendedXMP = ""

exiftool /Users/allenzhang/Downloads/PXL_20250722_065151464.MP.jpg

File Name                       : PXL_20250722_065151464.MP.jpg
File Size                       : 4.2 MB
Make                            : Google
Camera Model Name               : Pixel 4
XMP Toolkit                     : Adobe XMP Core 5.1.0-jc003
Motion Photo                    : 1
Motion Photo Version            : 1
Motion Photo Presentation Timestamp Us: 411003
Has Extended XMP                : 4938039014578563D928899A05F0B30F
Directory Item Mime             : image/jpeg, video/mp4
Directory Item Semantic         : Primary, MotionPhoto
Directory Item Length           : 0, 870399
Directory Item Padding          : 0, 0
Motion Photo Video              : (Binary data 870399 bytes, use -b option to extract)

ROOT NODE
 http://ns.google.com/photos/1.0/container/ = "Container:" (0x80000000 : SCHEMA_NODE)
  Container:Directory (0x600 : ARRAY | ARRAY_ORDERED)
   [1] (0x100 : STRUCT)
    Container:Item (0x100 : STRUCT)
     Item:Length = "0"
     Item:Mime = "image/jpeg"
     Item:Padding = "0"
     Item:Semantic = "Primary"
   [2] (0x100 : STRUCT)
    Container:Item (0x100 : STRUCT)
     Item:Length = "870399"
     Item:Mime = "video/mp4"
     Item:Padding = "0"
     Item:Semantic = "MotionPhoto"
 http://ns.google.com/photos/1.0/camera/ = "GCamera:" (0x80000000 : SCHEMA_NODE)
  GCamera:MotionPhoto = "1"
  GCamera:MotionPhotoPresentationTimestampUs = "411003"
  GCamera:MotionPhotoVersion = "1"
 http://ns.adobe.com/xmp/note/ = "xmpNote:" (0x80000000 : SCHEMA_NODE)
  xmpNote:HasExtendedXMP = "4938039014578563D928899A05F0B30F"

exiftool /Users/allenzhang/Downloads/IMG20250722163505.jpg

File Name                       : IMG20250722163505.jpg
File Size                       : 7.0 MB
Make                            : OPPO
Camera Model Name               : OPPO Find X8
XMP Toolkit                     : Adobe XMP Core 5.1.0-jc003
Version                         : 1.0
Motion Photo                    : 1
Motion Photo Version            : 1
Motion Photo Presentation Timestamp Us: 266704
Motion Photo Primary Presentation Timestamp Us: 266704
Motion Photo Owner              : oplus
O Live Photo Version            : 2
Video Length                    : 3334498
Directory Item Mime             : image/jpeg, image/jpeg, video/mp4
Directory Item Semantic         : Primary, GainMap, MotionPhoto
Directory Item Length           : 0, 474937, 3334834
Directory Item Padding          : 0, 0
Gain Map Image                  : (Binary data 3334834 bytes, use -b option to extract)
Motion Photo Video              : (Binary data 3334834 bytes, use -b option to extract)

ROOT NODE
 http://ns.google.com/photos/1.0/container/ = "Container:" (0x80000000 : SCHEMA_NODE)
  Container:Directory (0x600 : ARRAY | ARRAY_ORDERED)
   [1] (0x100 : STRUCT)
    Container:Item (0x100 : STRUCT)
     Item:Length = "0"
     Item:Mime = "image/jpeg"
     Item:Padding = "0"
     Item:Semantic = "Primary"
   [2] (0x100 : STRUCT)
    Container:Item (0x100 : STRUCT)
     Item:Length = "474937"
     Item:Mime = "image/jpeg"
     Item:Padding = "0"
     Item:Semantic = "GainMap"
   [3] (0x100 : STRUCT)
    Container:Item (0x100 : STRUCT)
     Item:Length = "3334834"
     Item:Mime = "video/mp4"
     Item:Semantic = "MotionPhoto"
 http://ns.google.com/photos/1.0/camera/ = "GCamera:" (0x80000000 : SCHEMA_NODE)
  GCamera:MotionPhoto = "1"
  GCamera:MotionPhotoPresentationTimestampUs = "266704"
  GCamera:MotionPhotoVersion = "1"
 http://ns.oplus.com/photos/1.0/camera/ = "OpCamera:" (0x80000000 : SCHEMA_NODE)
  OpCamera:MotionPhotoOwner = "oplus"
  OpCamera:MotionPhotoPrimaryPresentationTimestampUs = "266704"
  OpCamera:OLivePhotoVersion = "2"
  OpCamera:VideoLength = "3334498"
 http://ns.adobe.com/hdr-gain-map/1.0/ = "hdrgm:" (0x80000000 : SCHEMA_NODE)
  hdrgm:Version = "1.0"

文件總大小: 5.5 MB
├── 靜態(tài)圖片: 1.74 MB (約 31%)
└── 視頻數(shù)據(jù): 4.03 MB (約 69%)

文件總大小: 4.2 MB
├── 靜態(tài)圖片: 約 3.3 MB (約 79%)
├── 視頻數(shù)據(jù): 870 KB (約 20%)
└── Extended XMP: 少量元數(shù)據(jù)

文件總大小: 7.0 MB
├── 靜態(tài)圖片: 約 3.2 MB (約 46%)
├── GainMap (HDR): 475 KB (約 7%)
└── 視頻數(shù)據(jù): 3.3 MB (約 47%)

dependencies {
    // Adobe XMP SDK
    implementation 'com.adobe.xmp:xmpcore:6.1.11'

    // 協(xié)程支持
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'

    // 文件處理
    implementation 'androidx.core:core-ktx:1.12.0'
}

class UnifiedMotionPhotoExtractor {
    companionobject {
        constval TAG = "MotionPhotoExtractor"
        privateconstval BUFFER_SIZE = 8192

        // MP4文件頭標識
        privateval FTYP_SIGNATURE = byteArrayOf('f'.toByte(), 't'.toByte(), 'y'.toByte(), 'p'.toByte())
        privateval FTYPMP4_SIGNATURE = byteArrayOf('f'.toByte(), 't'.toByte(), 'y'.toByte(), 'p'.toByte(),
                                               'm'.toByte(), 'p'.toByte(), '4'.toByte())
        privateval FTYPMP42_SIGNATURE = byteArrayOf('f'.toByte(), 't'.toByte(), 'y'.toByte(), 'p'.toByte(),
                                                'm'.toByte(), 'p'.toByte(), '4'.toByte(), '2'.toByte())
        privateval FTYPISOM_SIGNATURE = byteArrayOf('f'.toByte(), 't'.toByte(), 'y'.toByte(), 'p'.toByte(),
                                                'i'.toByte(), 's'.toByte(), 'o'.toByte(), 'm'.toByte())

        // 元數(shù)據(jù)標簽
        privateconstval XIAOMI_MICRO_VIDEO = "MicroVideo"
        privateconstval XIAOMI_MICRO_VIDEO_OFFSET = "MicroVideoOffset"
        privateconstval GCAMERA_MICRO_VIDEO = "GCamera:MicroVideo"
        privateconstval GCAMERA_MICRO_VIDEO_OFFSET = "GCamera:MicroVideoOffset"
        privateconstval GOOGLE_MOTION_PHOTO = "GCamera:MotionPhoto"
        privateconstval OPPO_LIVE_PHOTO = "OpCamera:OLivePhotoVersion"

        // 進度回調(diào)間隔（字節(jié)數(shù)）
        privateconstval PROGRESS_INTERVAL = 100000

        // JPEG 段標記
        privateconstval JPEG_SOI = 0xFFD8
        privateconstval JPEG_APP1 = 0xFFE1
        privateconstval JPEG_SOS = 0xFFDA

        // XMP 頭標識常量
        privateval XMP_HEADER = "http://ns.adobe.com/xap/1.0/".toByteArray()
    }


    /**
     * 從 JPEG 文件中提取 XMP 元數(shù)據(jù)
     */
    privatefun extractXMPFromJPEG(filePath: String): XMPMeta? {
        returntry {
            RandomAccessFile(filePath, "r").use { raf ->
                // 驗證 JPEG 文件頭
                if (raf.readUnsignedShort() != JPEG_SOI) {
                    returnnull
                }

                while (true) {
                    // 讀取段標記
                    val marker = raf.readUnsignedShort()

                    // 如果到達圖像數(shù)據(jù)段，停止解析
                    if (marker == JPEG_SOS) {
                        break
                    }

                    // 只處理 APP1 段
                    if (marker == JPEG_APP1) {
                        val segmentLength = raf.readUnsignedShort()
                        val segmentData = ByteArray(segmentLength - 2)
                        raf.readFully(segmentData)

                        // 檢查是否為 XMP 數(shù)據(jù)
                        if (isXMPSegment(segmentData)) {
                            Log.d("chao"," 發(fā)現(xiàn) XMP 數(shù)據(jù)段，文件: ${filePath}")
                            return parseXMPFromSegment(segmentData)
                        }
                    } else {
                        // 跳過其他段
                        val segmentLength = raf.readUnsignedShort()
                        raf.skipBytes(segmentLength - 2)
                    }
                }
            }
            null
        } catch (e: Exception) {
            Log.e(TAG, "XMP 提取失敗: ${e.message}", e)
            null
        }
    }

    /**
     * 檢查是否為 XMP 段
     */
    privatefun isXMPSegment(data: ByteArray): Boolean {
        if (data.size < XMP_HEADER.size) returnfalse
        for (i in XMP_HEADER.indices) {
            if (data[i] != XMP_HEADER[i]) returnfalse
        }
        returntrue
    }

    /**
     * 從段數(shù)據(jù)中解析 XMP
     */
    privatefun parseXMPFromSegment(segmentData: ByteArray): XMPMeta? {
        returntry {
            val xmpDataStart = XMP_HEADER.size + 1// +1 for null terminator
            val xmpData = segmentData.copyOfRange(xmpDataStart, segmentData.size)
            XMPMetaFactory.parseFromBuffer(xmpData)
        } catch (e: XMPException) {
            Log.e(TAG, "XMP 解析失敗: ${e.message}", e)
            null
        }
    }


    // 這里是oppo手機提取xmp方法，其它手機的類似
    privatefun checkOppoLivePhotoInXMP(xmpMeta: XMPMeta): MotionPhotoResult? {
        returntry {
            val cameraNamespace = "http://ns.google.com/photos/1.0/camera/"
            val oppoNamespace = "http://ns.oplus.com/photos/1.0/camera/"http:// OPPO專有命名空間
            val containerNamespace = "http://ns.google.com/photos/1.0/container/"
            val hdrNamespace = "http://ns.adobe.com/hdr-gain-map/1.0/"

            // 首先檢查OPPO專有命名空間
            val oppoMotionPhotoOwner = try {
                xmpMeta.getPropertyString(oppoNamespace, "MotionPhotoOwner")
            } catch (e: Exception) { null }

            val oppoOLivePhotoVersion = try {
                xmpMeta.getPropertyString(oppoNamespace, "OLivePhotoVersion")
            } catch (e: Exception) { null }

            val oppoVideoLength = try {
                xmpMeta.getPropertyString(oppoNamespace, "VideoLength")?.toLongOrNull()
            } catch (e: Exception) { null }

            // 檢查標準命名空間中的Motion Photo標識
            val motionPhoto = try {
                xmpMeta.getPropertyInteger(cameraNamespace, "MotionPhoto")
            } catch (e: Exception) { null }

            // 如果是OPPO格式 (有OPPO專有標識或VideoLength字段)
            val isOppoFormat = oppoMotionPhotoOwner == "oplus" ||
                    oppoOLivePhotoVersion != null ||
                    oppoVideoLength != null

            if (motionPhoto == 1 && isOppoFormat) {
                Log.d("XMP", "檢測到OPPO O Live Photo格式")

                val version = try {
                    // 優(yōu)先使用OPPO版本，回退到標準版本
                    oppoOLivePhotoVersion?.toIntOrNull()
                        ?: xmpMeta.getPropertyInteger(cameraNamespace, "MotionPhotoVersion")
                } catch (e: Exception) { 1 }

                val timestamp = try {
                    // 優(yōu)先使用OPPO的Primary時間戳
                    xmpMeta.getPropertyLong(oppoNamespace, "MotionPhotoPrimaryPresentationTimestampUs")
                } catch (e: Exception) {
                    try {
                        // 回退到標準時間戳
                        xmpMeta.getPropertyLong(cameraNamespace, "MotionPhotoPresentationTimestampUs")
                    } catch (e2: Exception) { -1L }
                }

                // 解析Container結(jié)構獲取視頻大小和GainMap信息
                val containerInfo = parseOppoContainerInfo(xmpMeta, containerNamespace)

                // 優(yōu)先使用Container中的視頻大小，回退到OPPO的VideoLength字段
                val videoSize = containerInfo.videoSize.takeIf { it > 0 }
                    ?: oppoVideoLength ?: -1L

                // 檢查是否有HDR GainMap
                val hasHdrGainMap = try {
                    val hdrVersion = xmpMeta.getPropertyString(hdrNamespace, "Version")
                    hdrVersion != null && containerInfo.hasGainMap
                } catch (e: Exception) {
                    containerInfo.hasGainMap
                }

                Log.d("XMP", "OPPO檢測結(jié)果 - VideoSize: $videoSize, HasGainMap: $hasHdrGainMap, Version: $version")

                return MotionPhotoResult(
                    type = MotionPhotoType.OPPO_LIVE_PHOTO,
                    vendor = "OPPO",
                    version = version,
                    videoSize = videoSize,
                    presentationTimestamp = timestamp,
                    detectionMethod = "XMP SDK",
                    hasGainMap = hasHdrGainMap
                )
            }

            null
        } catch (e: Exception) {
            Log.e("XMP", "OPPO檢測失敗: ${e.message}", e)
            null
        }
    }



    /**
     * 提取OPPO動態(tài)照片中的視頻
     */
    privatefun extractVideo(
        inputFile: File,
        outputFile: File,
        videoSize: Long = 0L,
        videoOffset: Long = 0L,
        progressCallback: ((Long, Long) -> Unit)?
    ): Boolean {
        // OPPO動態(tài)照片可能包含增益圖，需要特殊處理
        // 這里使用簡化方法，直接搜索MP4文件頭
        val offset = findMp4HeaderOffset(inputFile.path)?:0

        Log.d(TAG,"找到視頻數(shù)據(jù)，偏移量: $offset")

        // 嘗試多個可能的偏移量
        val possibleOffsets = listOf(
            videoOffset,
            offset
        )

        for (tryOffset in possibleOffsets) {
            if (tryOffset < 0) continue

            val tempFile = File.createTempFile("motion_video_", ".mp4")
            extractVideoData(inputFile, tempFile, tryOffset, progressCallback)

            if (isValidMp4(tempFile)) {
                Log.d(TAG,"? 偏移量 $tryOffset 提取的文件是有效的MP4格式")
                tempFile.copyTo(outputFile, overwrite = true)
                tempFile.delete()
                returntrue
            }

            tempFile.delete()
        }

        return isValidMp4(outputFile)
    }

    /**
     * 查找MP4文件頭的偏移量
     */
    privatefun findMp4HeaderOffset(filePath: String): Long? {
        val file = File(filePath)
        if (!file.exists() || file.length() < 8) {
            returnnull
        }

        // 只搜索文件的后半部分，因為視頻通常在文件末尾
        val fileSize = file.length()
        val startOffset = maxOf(0, fileSize / 2)

        RandomAccessFile(filePath, "r").use { raf ->
            raf.seek(startOffset)

            val buffer = ByteArray(BUFFER_SIZE)
            val window = ByteArray(8) // 滑動窗口，用于查找簽名
            var bytesRead: Int
            var currentOffset = startOffset

            while (raf.read(buffer).also { bytesRead = it } > 0) {
                for (i in0 until bytesRead) {
                    // 更新滑動窗口
                    System.arraycopy(window, 1, window, 0, window.size - 1)
                    window[window.size - 1] = buffer[i]

                    // 檢查當前窗口是否包含任何一種MP4文件頭標識
                    val signatureOffset = containsSignature(window)
                    if (signatureOffset != -1) {
                        // 找到了MP4文件頭，返回文件中的實際偏移量
                        // 減去4是因為MP4的box大小字段在標識符之前
                        return currentOffset + i - (window.size - signatureOffset) + 1 - 4
                    }
                }
                currentOffset += bytesRead
            }
        }

        returnnull
    }

    /**
     * 檢查給定的字節(jié)數(shù)組是否包含任何一種MP4文件頭標識
     *
     * @return 如果包含，返回標識符在數(shù)組中的起始位置；否則返回-1
     */
    privatefun containsSignature(data: ByteArray): Int {
        // 按優(yōu)先級順序檢查各種MP4文件頭標識
        val signatures = listOf(FTYPMP42_SIGNATURE, FTYPMP4_SIGNATURE, FTYPISOM_SIGNATURE, FTYP_SIGNATURE)

        for (signature in signatures) {
            for (i in0..data.size - signature.size) {
                var found = true
                for (j in signature.indices) {
                    if (data[i + j] != signature[j]) {
                        found = false
                        break
                    }
                }
                if (found) return i
            }
        }

        return -1
    }

    /**
     * 從輸入文件的指定偏移量開始提取視頻數(shù)據(jù)到輸出文件
     */
    privatefun extractVideoData(
        inputFile: File,
        outputFile: File,
        offset: Long,
        progressCallback: ((Long, Long) -> Unit)?
    ) {
        val fileSize = inputFile.length()
        val videoSize = fileSize - offset

        FileInputStream(inputFile).use { input ->
            FileOutputStream(outputFile).use { output ->
                // 跳過偏移量之前的數(shù)據(jù)
                input.skip(offset)

                val buffer = ByteArray(BUFFER_SIZE)
                var bytesRead: Int
                var totalBytesRead: Long = 0
                var lastProgressUpdate: Long = 0

                while (input.read(buffer).also { bytesRead = it } > 0) {
                    output.write(buffer, 0, bytesRead)

                    totalBytesRead += bytesRead

                    // 更新進度
                    if (progressCallback != null && totalBytesRead - lastProgressUpdate > PROGRESS_INTERVAL) {
                        progressCallback(totalBytesRead, videoSize)
                        lastProgressUpdate = totalBytesRead
                    }
                }

                // 最終進度更新
                progressCallback?.invoke(totalBytesRead, videoSize)
            }
        }
    }

    /**
     * 檢查文件是否為有效的MP4格式
     */
    privatefun isValidMp4(file: File): Boolean {
        if (!file.exists() || file.length() < 8) returnfalse

        FileInputStream(file).use { input ->
            val header = ByteArray(8)
            if (input.read(header) != header.size) returnfalse

            // 檢查文件頭是否包含ftyp標識
            val headerStr = String(header, StandardCharsets.UTF_8)
            return headerStr.contains("ftyp")
        }
    }
}

/**
 * 動態(tài)照片播放組件
 * 支持靜態(tài)圖片顯示和視頻播放切換
 */
class MotionPhotoView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : FrameLayout(context, attrs, defStyleAttr) {

    privateval imageView: ImageView
    privateval videoView: VideoView
    privatevar motionPhotoResult: MotionPhotoResult? = null

    /**
     * 設置動態(tài)照片數(shù)據(jù)
     */
    fun setMotionPhoto(imagePath: String, result: MotionPhotoResult) {
        this.originalImagePath = imagePath
        this.motionPhotoResult = result
        // 顯示靜態(tài)圖片
        loadStaticImage(imagePath)
    }

    /**
     * 播放視頻
     */
    fun playVideo() {
        try {
            Log.d("MotionPhotoView", "開始播放視頻: $videoPath")
            videoView.setVideoPath(videoPath)
            videoView.isVisible = true
            imageView.isVisible = false
            videoView.start()
            isVideoPlaying = true

        } catch (e: Exception) {
            Log.e("MotionPhotoView", "播放視頻異常: ${e.message}", e)
            onError?.invoke("視頻播放失敗: ${e.message}")
            showStaticImage()
        }
    }

    /**
     * 停止視頻播放
     */
    fun stopVideo() {
        if (videoView.isPlaying) {
            videoView.stopPlayback()
        }
        showStaticImage()
    }

    /**
     * 暫停視頻
     */
    fun pauseVideo() {
        if (videoView.isPlaying) {
            videoView.pause()
        }
    }

    /**
     * 設置VideoView回調(diào)
     */
    privatefun setupVideoCallbacks() {
        videoView.setOnPreparedListener { mediaPlayer ->
            Log.d("MotionPhotoView", "視頻準備完成")

            // 設置循環(huán)播放
            if (autoLoop) {
                mediaPlayer.isLooping = true
            }
            // 根據(jù)時間戳定位播放位置
            motionPhotoResult?.presentationTimestamp?.let { timestamp ->
                if (timestamp > 0) {
                    val seekPosition = (timestamp / 1000).toInt() // 轉(zhuǎn)換為毫秒
                    Log.d("MotionPhotoView", "定位到時間戳: ${seekPosition}ms (原始: ${timestamp}μs)")
                    mediaPlayer.seekTo(seekPosition)
                }
            }
        }

        videoView.setOnCompletionListener {
            Log.d("MotionPhotoView", "視頻播放完成")
            if (!autoLoop) {
                showStaticImage()
            }
        }

        videoView.setOnErrorListener { _, what, extra ->
            showStaticImage()
            true
        }
    }
}