function unpackZip($file, $dir)
{
    if ($zip = zip_open(getcwd() . $file)) {
        if ($zip) {
            while ($zip_entry = zip_read($zip)) {
                if (zip_entry_open($zip, $zip_entry, "r")) {
                    $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                    $dir_name = dirname(zip_entry_name($zip_entry));
                    if ($dir_name == "." || !is_dir($dir_name)) {
                        $dir_op = $dir;
                        foreach (explode("/", $dir_name) as $k) {
                            $dir_op = $dir_op . $k;
                            if (is_file($dir_op)) {
                                unlink($dir_op);
                            }
                            if (!is_dir($dir_op)) {
                                mkdir($dir_op);
                            }
                            $dir_op = $dir_op . "/";
                        }
                    }
                    $fp = fopen($dir . zip_entry_name($zip_entry), "w");
                    fwrite($fp, $buf);
                    zip_entry_close($zip_entry);
                } else {
                    return false;
                }
            }
            zip_close($zip);
        }
    } else {
        return false;
    }
    return true;
}

 private function read_docx()
 {
     $striped_content = '';
     $content = '';
     $zip = zip_open($this->filename);
     if (!$zip || is_numeric($zip)) {
         return false;
     }
     while ($zip_entry = zip_read($zip)) {
         if (zip_entry_open($zip, $zip_entry) == FALSE) {
             continue;
         }
         if (zip_entry_name($zip_entry) != "word/document.xml") {
             continue;
         }
         $content .= zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
         zip_entry_close($zip_entry);
     }
     // end while
     zip_close($zip);
     $content = str_replace('</w:r></w:p></w:tc><w:tc>', " ", $content);
     $content = str_replace('</w:r></w:p>', "\r\n", $content);
     $striped_content = strip_tags($content);
     return $striped_content;
 }

function getLayoutData($layout, $fileName, $usage, $install = false)
{
    $output = "";
    $zip = zip_open(($install == false ? 'layouts/' : '../layouts/') . $layout . '.zip');
    if ($zip) {
        while ($zip_entry = zip_read($zip)) {
            $file = basename(zip_entry_name($zip_entry));
            if (zip_entry_open($zip, $zip_entry, 'r')) {
                if ($usage == "include" && strpos($file, $fileName) !== FALSE) {
                    $output = 'phar://layouts/' . $layout . '.zip/' . zip_entry_name($zip_entry);
                }
                if ($usage == "echo") {
                    $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                    if (strpos(strval($file), strval($fileName)) !== FALSE) {
                        if (strpos($file, 'settings') !== FALSE) {
                            $output = json_decode($buf, true);
                        } else {
                            $output = $buf;
                        }
                    }
                }
            }
        }
        zip_close($zip);
    }
    return $output;
}

 public function close()
 {
     if (is_resource($this->handler)) {
         zip_close($this->handler);
         $this->handler = NULL;
     }
 }

 /**
  * Test if the Epub conversion works correctly
  *
  * @return void
  */
 public function testConversion()
 {
     $this->epub->setInputFile($this->testInputFile);
     $this->epub->setOutputFile($this->testOutputFile);
     $this->epub->convert();
     $this->assertTrue($this->epub->getStatus());
     $this->assertNotSame(file_get_contents($this->testInputFile), file_get_contents($this->testOutputFile));
     $finfo = finfo_open(FILEINFO_MIME_TYPE);
     $mimeType = finfo_file($finfo, $this->testOutputFile);
     $this->assertSame($mimeType, 'application/epub+zip');
     $epubZip = zip_open($this->testOutputFile);
     $this->assertTrue(is_resource($epubZip));
     $foundContent = false;
     $foundGraphics = false;
     while ($zipDir = zip_read($epubZip)) {
         $zipDirName = zip_entry_name($zipDir);
         if ($zipDirName == $this->expectedContentFile) {
             $foundContent = true;
         }
         if (strpos($zipDirName, $this->expectedGraphicsDir)) {
             $foundGraphics = true;
         }
     }
     zip_close($epubZip);
     $this->assertTrue($foundContent);
     $this->assertTrue($foundGraphics);
 }

 public static function parse($filename)
 {
     $striped_content = '';
     $content = '';
     if (!$filename || !file_exists($filename)) {
         return false;
     }
     $zip = zip_open($filename);
     if (!$zip || is_numeric($zip)) {
         return false;
     }
     while ($zip_entry = zip_read($zip)) {
         if (zip_entry_open($zip, $zip_entry) == FALSE) {
             continue;
         }
         if (zip_entry_name($zip_entry) != "content.xml") {
             continue;
         }
         $content .= zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
         zip_entry_close($zip_entry);
     }
     zip_close($zip);
     $content = str_replace('</w:r></w:p></w:tc><w:tc>', " ", $content);
     $content = str_replace('</w:r></w:p>', "\r\n", $content);
     $striped_content = strip_tags($content);
     return $striped_content;
 }

 /**
  * This action handles import action.
  *
  * It must be reached by a POST request.
  *
  * Parameter is:
  *   - file (default: nothing!)
  * Available file types are: zip, json or xml.
  */
 public function importAction()
 {
     if (!Minz_Request::isPost()) {
         Minz_Request::forward(array('c' => 'importExport', 'a' => 'index'), true);
     }
     $file = $_FILES['file'];
     $status_file = $file['error'];
     if ($status_file !== 0) {
         Minz_Log::error('File cannot be uploaded. Error code: ' . $status_file);
         Minz_Request::bad(_t('feedback.import_export.file_cannot_be_uploaded'), array('c' => 'importExport', 'a' => 'index'));
     }
     @set_time_limit(300);
     $type_file = $this->guessFileType($file['name']);
     $list_files = array('opml' => array(), 'json_starred' => array(), 'json_feed' => array());
     // We try to list all files according to their type
     $list = array();
     if ($type_file === 'zip' && extension_loaded('zip')) {
         $zip = zip_open($file['tmp_name']);
         if (!is_resource($zip)) {
             // zip_open cannot open file: something is wrong
             Minz_Log::error('Zip archive cannot be imported. Error code: ' . $zip);
             Minz_Request::bad(_t('feedback.import_export.zip_error'), array('c' => 'importExport', 'a' => 'index'));
         }
         while (($zipfile = zip_read($zip)) !== false) {
             if (!is_resource($zipfile)) {
                 // zip_entry() can also return an error code!
                 Minz_Log::error('Zip file cannot be imported. Error code: ' . $zipfile);
             } else {
                 $type_zipfile = $this->guessFileType(zip_entry_name($zipfile));
                 if ($type_file !== 'unknown') {
                     $list_files[$type_zipfile][] = zip_entry_read($zipfile, zip_entry_filesize($zipfile));
                 }
             }
         }
         zip_close($zip);
     } elseif ($type_file === 'zip') {
         // Zip extension is not loaded
         Minz_Request::bad(_t('feedback.import_export.no_zip_extension'), array('c' => 'importExport', 'a' => 'index'));
     } elseif ($type_file !== 'unknown') {
         $list_files[$type_file][] = file_get_contents($file['tmp_name']);
     }
     // Import file contents.
     // OPML first(so categories and feeds are imported)
     // Starred articles then so the "favourite" status is already set
     // And finally all other files.
     $error = false;
     foreach ($list_files['opml'] as $opml_file) {
         $error = $this->importOpml($opml_file);
     }
     foreach ($list_files['json_starred'] as $article_file) {
         $error = $this->importJson($article_file, true);
     }
     foreach ($list_files['json_feed'] as $article_file) {
         $error = $this->importJson($article_file);
     }
     // And finally, we get import status and redirect to the home page
     Minz_Session::_param('actualize_feeds', true);
     $content_notif = $error === true ? _t('feedback.import_export.feeds_imported_with_errors') : _t('feedback.import_export.feeds_imported');
     Minz_Request::good($content_notif);
 }

function getZipHeaderFilepointer($filename, &$MP3fileInfo)
{
    if (!function_exists('zip_open')) {
        $MP3fileInfo['error'] = "\n" . 'Zip functions not available (requires at least PHP 4.0.7RC1 and ZZipLib (http://zziplib.sourceforge.net/) - see http://www.php.net/manual/en/ref.zip.php)';
        return FALSE;
    } else {
        if ($zip = zip_open($filename)) {
            $zipentrycounter = 0;
            while ($zip_entry = zip_read($zip)) {
                $MP3fileInfo['zip']['entries']["{$zipentrycounter}"]['name'] = zip_entry_name($zip_entry);
                $MP3fileInfo['zip']['entries']["{$zipentrycounter}"]['filesize'] = zip_entry_filesize($zip_entry);
                $MP3fileInfo['zip']['entries']["{$zipentrycounter}"]['compressedsize'] = zip_entry_compressedsize($zip_entry);
                $MP3fileInfo['zip']['entries']["{$zipentrycounter}"]['compressionmethod'] = zip_entry_compressionmethod($zip_entry);
                //if (zip_entry_open($zip, $zip_entry, "r")) {
                //	$MP3fileInfo['zip']['entries']["$zipentrycounter"]['contents'] = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                //	zip_entry_close($zip_entry);
                //}
                $zipentrycounter++;
            }
            zip_close($zip);
            return TRUE;
        } else {
            $MP3fileInfo['error'] = "\n" . 'Could not open file';
            return FALSE;
        }
    }
}

 function GenerateInfos()
 {
     $zip = zip_open($this->zipFile);
     $folder_count = 0;
     $file_count = 0;
     $unzipped_size = 0;
     $ext_array = array();
     $ext_count = array();
     //$entries_list      = array ();
     $entries_name = array();
     if ($zip) {
         while ($zip_entry = zip_read($zip)) {
             $zip_entry_name = zip_entry_name($zip_entry);
             if (is_dir($zip_entry_name)) {
                 $folder_count++;
             } else {
                 //$entries_list[]=$zip_entry;
                 $entries_name[] = $zip_entry_name;
                 $file_count++;
             }
             $path_parts = pathinfo(zip_entry_name($zip_entry));
             $ext = strtolower(trim(isset($path_parts['extension']) ? $path_parts['extension'] : ''));
             if ($ext != '') {
                 $ext_count[$ext]['count'] = isset($ext_count[$ext]['count']) ? $ext_count[$ext]['count'] : 0;
                 $ext_count[$ext]['count']++;
             }
             $unzipped_size = $unzipped_size + zip_entry_filesize($zip_entry);
         }
     }
     $zipped_size = $this->get_file_size_unit(filesize($this->zipFile));
     $unzipped_size = $this->get_file_size_unit($unzipped_size);
     $zip_info = array("folders" => $folder_count, "files" => $file_count, "zipped_size" => $zipped_size, "unzipped_size" => $unzipped_size, "file_types" => $ext_count, "entries_name" => $entries_name);
     zip_close($zip);
     return $zip_info;
 }

 function unzip($file, $dir = 'unzip/')
 {
     if (!file_exists($dir)) {
         mkdir($dir, 0777);
     }
     $zip_handle = zip_open($file);
     if (is_resource($zip_handle)) {
         while ($zip_entry = zip_read($zip_handle)) {
             if ($zip_entry) {
                 $zip_name = zip_entry_name($zip_entry);
                 $zip_size = zip_entry_filesize($zip_entry);
                 if ($zip_size == 0 && $zip_name[strlen($zip_name) - 1] == '/') {
                     mkdir($dir . $zip_name, 0775);
                 } else {
                     @zip_entry_open($zip_handle, $zip_entry, 'r');
                     $fp = @fopen($dir . $zip_name, 'wb+');
                     @fwrite($fp, zip_entry_read($zip_entry, $zip_size), $zip_size);
                     @fclose($fp);
                     @chmod($dir . $zip_name, 0775);
                     @zip_entry_close($zip_entry);
                 }
             }
         }
         return true;
     } else {
         zip_close($zip_handle);
         return false;
     }
 }

function unzip($zipfile)
{
    $zip = zip_open($zipfile);
    while ($zip_entry = zip_read($zip)) {
        zip_entry_open($zip, $zip_entry);
        if (substr(zip_entry_name($zip_entry), -1) == '/') {
            $zdir = substr(zip_entry_name($zip_entry), 0, -1);
            if (file_exists($zdir)) {
                trigger_error('Directory "<b>' . $zdir . '</b>" exists', E_USER_ERROR);
                return false;
            }
            mkdir($zdir);
        } else {
            $name = zip_entry_name($zip_entry);
            if (file_exists($name)) {
                trigger_error('File "<b>' . $name . '</b>" exists', E_USER_ERROR);
                return false;
            }
            $fopen = fopen($name, "w");
            fwrite($fopen, zip_entry_read($zip_entry, zip_entry_filesize($zip_entry)), zip_entry_filesize($zip_entry));
        }
        zip_entry_close($zip_entry);
    }
    zip_close($zip);
    return true;
}

 function unpackInto($file_path, $dir_path)
 {
     $zip = zip_open($file_path);
     if (!is_dir($dir_path)) {
         throw new Exception($dir_path . ' should be a directory but isn\'t.');
     }
     if ($zip) {
         while ($zip_entry = zip_read($zip)) {
             zip_entry_open($zip, $zip_entry);
             if (substr(zip_entry_name($zip_entry), -1) == '/') {
                 //this $zip_entry is a directory. create it.
                 $zdir = substr(zip_entry_name($zip_entry), 0, -1);
                 mkdir($dir_path . '/' . $zdir);
             } else {
                 $file = basename(zip_entry_name($zip_entry));
                 $fp = fopen($dir_path . '/' . zip_entry_name($zip_entry), "w+");
                 //echo zip_entry_name($zip_entry);
                 if (zip_entry_open($zip, $zip_entry, "r")) {
                     $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                     zip_entry_close($zip_entry);
                 }
                 fwrite($fp, $buf);
                 fclose($fp);
             }
         }
         zip_close($zip);
     }
 }

 public function read_file_docx($filename)
 {
     $striped_content = '';
     $content = '';
     if (!$filename || !file_exists($filename)) {
         return false;
     }
     $zip = zip_open($filename);
     if (!$zip || is_numeric($zip)) {
         return false;
     }
     while ($zip_entry = zip_read($zip)) {
         if (zip_entry_open($zip, $zip_entry) == FALSE) {
             continue;
         }
         if (zip_entry_name($zip_entry) != "word/document.xml") {
             continue;
         }
         $content .= zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
         zip_entry_close($zip_entry);
     }
     // end while
     zip_close($zip);
     //echo $content;
     //echo "<hr>";
     //file_put_contents('1.xml', $content);
     $content = str_replace('</w:r></w:p></w:tc><w:tc>', " ", $content);
     $content = str_replace('</w:r></w:p>', "\r\n", $content);
     $striped_content = strip_tags($content);
     return $striped_content;
 }

 /**
  * APP版本更新接口
  * @date: 2016年1月10日 下午9:30:33
  *
  * @author : Elliot
  * @param
  *            : none
  * @return :
  */
 public function version_get()
 {
     $dir = 'data';
     $dh = @opendir($dir);
     $return = array();
     while ($file = @readdir($dh)) {
         // 循环读取目录下的文件
         if ($file != '.' and $file != '..') {
             $path = $dir . DIRECTORY_SEPARATOR . $file;
             // 设置目录，用于含有子目录的情况
             if (is_file($path)) {
                 $filetime[] = date("Y-m-d H:i:s", filemtime($path));
                 // 获取文件最近修改日期
                 $return[] = $dir . DIRECTORY_SEPARATOR . $file;
             }
         }
     }
     @closedir($dh);
     // 关闭目录流
     array_multisort($filetime, SORT_DESC, SORT_STRING, $return);
     // 按时间排序
     $file = current($return);
     $zip = zip_open($file);
     if ($zip) {
         while ($zip_entry = zip_read($zip)) {
             if (zip_entry_name($zip_entry) == self::INSTALLPACKETVERSIONFILE && zip_entry_open($zip, $zip_entry, "r")) {
                 $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                 zip_entry_close($zip_entry);
             }
         }
         zip_close($zip);
     }
     $result = array('version' => $buf, 'url' => 'http://' . $_SERVER['SERVER_NAME'] . DIRECTORY_SEPARATOR . $file);
     $this->response($result, 200);
 }

 public function unzip($file)
 {
     $zip = zip_open(realpath(".") . "/" . $file);
     if (!$zip) {
         return "Unable to proccess file '{$file}'";
     }
     $e = '';
     while ($zip_entry = zip_read($zip)) {
         $zdir = dirname(zip_entry_name($zip_entry));
         $zname = zip_entry_name($zip_entry);
         if (!zip_entry_open($zip, $zip_entry, "r")) {
             $e .= "Unable to proccess file '{$zname}'";
             continue;
         }
         if (!is_dir($zdir)) {
             mkdirr($zdir, 0777);
         }
         #print "{$zdir} | {$zname} \n";
         $zip_fs = zip_entry_filesize($zip_entry);
         if (empty($zip_fs)) {
             continue;
         }
         $zz = zip_entry_read($zip_entry, $zip_fs);
         $z = fopen($zname, "w");
         fwrite($z, $zz);
         fclose($z);
         zip_entry_close($zip_entry);
     }
     zip_close($zip);
     return $e;
 }

function list_zip_files($id)
{
    if (!($r = open_zip_archive($id))) {
        return false;
    }
    $zip = $r["handle"];
    $result = array();
    $idx = 0;
    while ($entry = zip_read($zip)) {
        $path = zip_entry_name($entry);
        $components = explode("/", $path);
        $filename = $components[count($components) - 1];
        /*
         * Remove
         * - filenames that begin with .
         * - .class
         * - .prefs
         * - paths ending with / (directory names)
         * - paths that contain .metadata
         */
        if (substr($filename, 0, 1) != "." && !endswith($filename, ".class") && !endswith($filename, ".prefs") && !endswith($path, "/") && strpos($path, ".metadata") === FALSE) {
            $result[$idx] = $filename;
        }
        $idx++;
    }
    zip_close($zip);
    return $result;
}

 function extract_zip($zipfile, $dir)
 {
     if (function_exists('zip_open')) {
         $zip = zip_open($zipfile);
         if ($zip) {
             while ($zip_entry = zip_read($zip)) {
                 if (zip_entry_filesize($zip_entry) > 0) {
                     if (zip_entry_open($zip, $zip_entry, "r")) {
                         $buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                         zip_entry_close($zip_entry);
                         file_put($dir . '/' . zip_entry_name($zip_entry), $buf);
                     }
                 } else {
                     dir_create($dir . '/' . zip_entry_name($zip_entry));
                 }
             }
             zip_close($zip);
         }
     } else {
         $array = $this->list_zip($zipfile);
         $count = count($array);
         $f = 0;
         $d = 0;
         for ($i = 0; $i < $count; $i++) {
             if ($array[$i]['folder'] == 0) {
                 if ($this->extract_file($zipfile, $dir, $i) > 0) {
                     $f++;
                 }
             } else {
                 $d++;
             }
         }
     }
     return true;
 }

 static function unpack($archive, $out_folder, $file_name = '')
 {
     $zip = zip_open($archive);
     while ($zip_entry = zip_read($zip)) {
         $zip_entry_name = zip_entry_name($zip_entry);
         if ($zip_entry_name != '.DS_Store') {
             $zip_entry_size = zip_entry_filesize($zip_entry);
             if ($zip_entry_size == 0) {
                 if (!file_exists($out_folder . $zip_entry_name) && !@mkdir($out_folder . $zip_entry_name)) {
                     throw new Exception('Can not create folder <strong>' . $out_folder . $zip_entry_name . '</strong>. Permissions denied.');
                 }
             } else {
                 if (!$file_name || $out_folder . $zip_entry_name == $file_name) {
                     if (!@file_put_contents($out_folder . $zip_entry_name, zip_entry_read($zip_entry, $zip_entry_size))) {
                         throw new Exception('Can not unpack file <strong>' . $out_folder . $zip_entry_name . '</strong>. Permissions denied.');
                     }
                     if ($file_name) {
                         break;
                     }
                 }
             }
         }
     }
     zip_close($zip);
 }

function caching($comics_id, $zip_path, $image_ext)
{
    $comic = zip_open($zip_path);
    if (!is_resource($comic)) {
        die("[ERR]ZIP_OPEN : " . $zip_path);
    }
    $inzip_path = "";
    $count = 0;
    $files = null;
    $db = new SQLite3(DB);
    $db->exec("BEGIN DEFERRED;");
    while (($entry = zip_read($comic)) !== false) {
        $inzip_path = zip_entry_name($entry);
        $cache_name = md5($zip_path . "/" . $inzip_path) . '.' . get_ext($inzip_path);
        // 画像か否か
        if (!is_image($inzip_path, $image_ext)) {
            continue;
        }
        $data = zip_entry_read($entry, zip_entry_filesize($entry));
        $filepath = CACHE . '/' . $cache_name;
        file_put_contents($filepath, $data);
        $count++;
        query("INSERT INTO images (comics_id, page, filepath) VALUES (" . $comics_id . ", " . $count . ", '" . $filepath . "')", $db);
    }
    zip_close($comic);
    query("UPDATE comics SET pages = " . $count . " WHERE id = " . $comics_id, $db);
    $db->exec("COMMIT;");
}

/**
 * les deux fonction suivante ont été récupéré dans les exemples de php.net puis adapté pour leed. 
 *
 * Unzip the source_file in the destination dir
 *
 * @param   string      The path to the ZIP-file.
 * @param   string      The path where the zipfile should be unpacked, if false the directory of the zip-file is used
 * @param   boolean     Indicates if the files will be unpacked in a directory with the name of the zip-file (true) or not (false) (only if the destination directory is set to false!)
 * @param   boolean     Overwrite existing files (true) or not (false)
 *  
 * @return  boolean     Succesful or not
 */
function unzip_leed($src_file, $dest_dir = false, $create_zip_name_dir = true, $overwrite = true)
{
    if ($zip = zip_open($src_file)) {
        if ($zip) {
            $splitter = $create_zip_name_dir === true ? "." : "/";
            if ($dest_dir === false) {
                $dest_dir = substr($src_file, 0, strrpos($src_file, $splitter)) . "/";
            }
            // Create the directories to the destination dir if they don't already exist
            create_dirs($dest_dir);
            // For every file in the zip-packet
            while ($zip_entry = zip_read($zip)) {
                // Now we're going to create the directories in the destination directories
                // If the file is not in the root dir
                $pos_last_slash = strrpos(zip_entry_name($zip_entry), "/");
                if ($pos_last_slash !== false) {
                    // Create the directory where the zip-entry should be saved (with a "/" at the end)
                    $interne_dir = str_replace("Leed-master/", "", substr(zip_entry_name($zip_entry), 0, $pos_last_slash + 1));
                    $interne_dir = str_replace("Leed-multi_user/", "", $interne_dir);
                    $interne_dir = str_replace("Leed-market-master/", "", $interne_dir);
                    $interne_dir = str_replace("Leed-market-multi_user/", "", $interne_dir);
                    $interne_dir = str_replace("Leed-dev/", "", $interne_dir);
                    create_dirs($dest_dir . $interne_dir);
                }
                // Open the entry
                if (zip_entry_open($zip, $zip_entry, "r")) {
                    // The name of the file to save on the disk
                    $file_name = $dest_dir . zip_entry_name($zip_entry);
                    // Check if the files should be overwritten or not
                    if ($overwrite === true || $overwrite === false && !is_file($file_name)) {
                        // Get the content of the zip entry
                        $fstream = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
                        $file_name = str_replace("Leed-master/", "", $file_name);
                        $file_name = str_replace("Leed-multi_user/", "", $file_name);
                        $file_name = str_replace("Leed-market-master/", "", $file_name);
                        $file_name = str_replace("Leed-market-multi_user/", "", $file_name);
                        $file_name = str_replace("Leed-dev/", "", $file_name);
                        if (is_dir($file_name)) {
                            echo "répertoire: " . $file_name . "<br />";
                        } else {
                            if (file_put_contents($file_name, $fstream) === false) {
                                echo "erreur copie: " . $file_name . "<br />";
                            } else {
                                echo "copie: " . $file_name . "<br />";
                            }
                        }
                    }
                    // Close the entry
                    zip_entry_close($zip_entry);
                }
            }
            // Close the zip-file
            zip_close($zip);
        }
    } else {
        return false;
    }
    return true;
}