/// <summary>
/// Attempts to untar a tar archive and to copy its content into a folder.
/// If it succeeds, the resulting images are added to the files to be added into the generation.
/// </summary>
/// <param name="path">Path of the tar archive to be checked.</param>
private void CheckTarArchive(string path)
{
try
{
using (FileStream stream = new FileStream(path, FileMode.Open))
{
using (TarArchive tarFile = TarArchive.CreateInputTarArchive(stream))
{
int pathIndex = Data.Files.IndexOf(path);
string tarPath = GenerateArchivePath(path);
tarFile.ExtractContents(tarPath);
List <string> newFiles = new List <string>();
ParseExtractedElements(newFiles, new DirectoryInfo(tarPath));
InsertArchiveFiles(pathIndex, newFiles);
}
}
}
catch
{
tarErrors.Add(path);
Data.Files.Remove(path);
}
}
/// <summary>
/// Simple full extract from a TGZ
/// https://github.com/icsharpcode/SharpZipLib/wiki/GZip-and-Tar-Samples
/// </summary>
/// <param name="inputFile"></param>
/// <param name="dstFolder"></param>
private static void ExtractTarGz(string inputFile, string dstFolder)
{
using var inputStream = new FileStream(inputFile, FileMode.Open, FileAccess.Read);
using var gzipStream = new GZipInputStream(inputStream);
using var tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(dstFolder);
}
public void EmptyTar()
{
var ms = new MemoryStream();
int recordSize = 0;
using (TarArchive tarOut = TarArchive.CreateOutputTarArchive(ms))
{
recordSize = tarOut.RecordSize;
}
Assert.IsTrue(ms.GetBuffer().Length > 0, "Archive size must be > zero");
Assert.AreEqual(ms.GetBuffer().Length % recordSize, 0, "Archive size must be a multiple of record size");
var ms2 = new MemoryStream();
ms2.Write(ms.GetBuffer(), 0, ms.GetBuffer().Length);
ms2.Seek(0, SeekOrigin.Begin);
using (TarArchive tarIn = TarArchive.CreateInputTarArchive(ms2))
{
entryCount = 0;
tarIn.ProgressMessageEvent += EntryCounter;
tarIn.ListContents();
Assert.AreEqual(0, entryCount, "Expected 0 tar entries");
}
}
public static void ExtractTGZ(String gzArchiveName, String destFolder)
{
var flag = gzArchiveName.Split(Path.DirectorySeparatorChar).Last().Split('.').First() + ".bin";
if (File.Exists(Path.Combine(destFolder, flag)))
{
return;
}
Binding.tf_output_redirect.WriteLine($"Extracting.");
var task = Task.Run(() =>
{
using (var inStream = File.OpenRead(gzArchiveName))
{
using (var gzipStream = new GZipInputStream(inStream))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
tarArchive.ExtractContents(destFolder);
}
}
});
while (!task.IsCompleted)
{
Thread.Sleep(200);
Binding.tf_output_redirect.Write(".");
}
File.Create(Path.Combine(destFolder, flag));
Binding.tf_output_redirect.WriteLine("");
Binding.tf_output_redirect.WriteLine("Extracting is completed.");
}
/// <summary>
/// The decompress appliance.
/// </summary>
private void DecompressAppliance()
{
using (FileStream fileStream = File.OpenRead(VirtualAppliance))
{
TarArchive appliance = TarArchive.CreateInputTarArchive(fileStream);
Directory.CreateDirectory(temporaryFolder);
appliance.ExtractContents(temporaryFolder);
appliance.Close();
}
// Get the extracted contents..
foreach (string file in Directory.GetFiles(temporaryFolder))
{
var fInfo = new FileInfo(file);
switch (fInfo.Extension)
{
case ".ovf":
Ovf = file;
break;
case ".mf":
Manifest = file;
break;
case ".vmdk":
VirtualImage = file;
break;
}
}
}
private bool ExtractTar(string archive, SPath outFolder, CancellationToken cancellationToken,
Action <string, long> onStart, Func <long, long, string, bool> onProgress, Func <string, bool> onFilter = null)
{
TarArchive zf = null;
try
{
List <IArchiveEntry> entries;
using (var read = TarArchive.CreateInputTarArchive(SPath.FileSystem.OpenRead(archive)))
{
entries = PreprocessEntries(outFolder, read, onStart, onFilter);
}
zf = TarArchive.CreateInputTarArchive(SPath.FileSystem.OpenRead(archive));
return(ExtractArchive(archive, outFolder, cancellationToken, zf, entries, onStart, onProgress, onFilter));
}
catch (Exception ex)
{
LogHelper.GetLogger <ZipHelper>().Error(ex);
throw;
}
finally
{
zf?.Close(); // Ensure we release resources
}
}
internal static List <string> UncompressTgz(string archiveName, string destinationFolder)
{
List <string> extractedFiles = new List <string>();
try
{
Stream inStream = File.OpenRead(archiveName);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ProgressMessageEvent += (archive, entry, message) => {
extractedFiles.Add(entry.Name);
};
tarArchive.ExtractContents(destinationFolder);
tarArchive.ListContents();
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
catch (Exception e)
{
Console.WriteLine("UnTar error: " + e.Message);
}
return(extractedFiles);
}
public static string DecodeArchiveAndGetVideoPath(string username, string foldername)
{
string fullPath = resultsPath + "/" + username + "/" + foldername + "/";
string destinationFolder = resultsPath + "/" + username + "/" + foldername + "/" + "data";
if (!File.Exists(fullPath + "data.tgz"))
{
return(GetVideoPathWithoutDecoding(username, foldername));
}
var inStream = new FileStream(fullPath + "data.tgz", FileMode.Open);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(destinationFolder);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
//remove archive
File.Delete(fullPath + "data.tgz");
string videoPath = Directory.GetDirectories(destinationFolder)[0] + "/video.mp4";
return(videoPath);
}
public static void ExtractTGZ(string gzArchiveName, string destFolder)
{
var flag = gzArchiveName.Split(Path.DirectorySeparatorChar).Last().Split('.').First() + ".bin";
if (File.Exists(Path.Combine(destFolder, flag)))
{
return;
}
Console.WriteLine($"Extracting.");
var task = Task.Run(() => {
using (var inStream = File.OpenRead(gzArchiveName)) {
using (var gzipStream = new GZipInputStream(inStream)) {
#pragma warning disable CS0618 // Type or member is obsolete
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
#pragma warning restore CS0618 // Type or member is obsolete
tarArchive.ExtractContents(destFolder);
}
}
});
while (!task.IsCompleted)
{
Thread.Sleep(200);
Console.Write(".");
}
File.Create(Path.Combine(destFolder, flag));
Console.WriteLine("");
Console.WriteLine("Extraction completed.");
}
public static PluginMetadataCollection FromStream(Stream stream)
{
var memStream = new MemoryStream();
stream.CopyTo(memStream);
using (memStream)
using (var gzipStream = new GZipInputStream(memStream))
using (var archive = TarArchive.CreateInputTarArchive(gzipStream, null))
{
string hash = CalculateSHA256(memStream);
string cacheDir = Path.Join(AppInfo.Current.CacheDirectory, $"{hash}-OpenTabletDriver-PluginMetadata");
if (Directory.Exists(cacheDir))
{
Directory.Delete(cacheDir, true);
}
archive.ExtractContents(cacheDir);
var collection = EnumeratePluginMetadata(cacheDir);
var metadataCollection = new PluginMetadataCollection(collection);
return(metadataCollection);
}
}
public static bool ExtractTGZ(String gzArchiveName, String destFolder)
{
Stream inStream = File.OpenRead(gzArchiveName);
Stream gzipStream;
TarArchive tarArchive;
try
{
gzipStream = new BZip2InputStream(inStream);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
return(false);
}
try
{
tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
return(false);
}
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
return(true);
}
public async Task Install(string path)
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
Directory.CreateDirectory(path);
try
{
await Task.Factory.StartNew(() =>
{
using (var targzStream = _installSource.Get())
{
using (var tarStream = new GZipStream(targzStream, CompressionMode.Decompress, true))
{
using (var zipArchive = TarArchive.CreateInputTarArchive(tarStream))
{
zipArchive.ExtractContents(path);
}
}
}
}, TaskCreationOptions.LongRunning);
}
catch (Exception)
{
Directory.Delete(path, false);
throw;
}
}
/// <summary>Downloads the and extract.</summary>
/// <param name="uri"> URI of the resource.</param>
/// <param name="packageName"> Name of the package.</param>
/// <param name="version"> The version.</param>
/// <param name="specDirectory">Pathname of the specifier directory.</param>
/// <returns>True if it succeeds, false if it fails.</returns>
private static bool DownloadAndExtract(
Uri uri,
string packageName,
string version,
string specDirectory)
{
try
{
// build our extraction directory name
string directory = Path.Combine(specDirectory, $"{packageName}-{version}");
// make sure our destination directory exists
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using (Stream fileStream = _httpClient.GetStreamAsync(uri).Result)
using (Stream gzipStream = new GZipInputStream(fileStream))
using (TarArchive tar = TarArchive.CreateInputTarArchive(gzipStream))
{
// extract
tar.ExtractContents(directory);
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine($"DownloadPublishedPackage <<< failed to download package: {packageName}-{version}: {ex.Message}");
throw;
}
}
public async Task GetTar_RawLeaves()
{
var temp = MakeTemp();
try
{
var options = new AddFileOptions
{
RawLeaves = true
};
var dir = ipfs.UnixFsApi.AddDirectoryAsync(temp, true, options).Result;
var dirid = dir.Id.Encode();
var tar = await ipfs.UnixFsApi.GetAsync(dir.Id);
var archive = TarArchive.CreateInputTarArchive(tar);
var files = new List <string>();
archive.ProgressMessageEvent += (a, e, m) => { files.Add(e.Name); };
archive.ListContents();
Assert.AreEqual($"{dirid}", files[0]);
Assert.AreEqual($"{dirid}/alpha.txt", files[1]);
Assert.AreEqual($"{dirid}/beta.txt", files[2]);
Assert.AreEqual($"{dirid}/x", files[3]);
Assert.AreEqual($"{dirid}/x/x.txt", files[4]);
Assert.AreEqual($"{dirid}/x/y", files[5]);
Assert.AreEqual($"{dirid}/x/y/y.txt", files[6]);
}
finally
{
Directory.Delete(temp, true);
}
}
void ExtractTar(Stream tarSteam)
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(tarSteam, TarBuffer.DefaultBlockFactor))
{
tarArchive.ExtractContents(LogOutputDirectory);
}
}
/// <summary>
/// Downloads and prepares the MNIST dataset.
/// </summary>
///
/// <param name="path">The path where datasets will be stored. If null or empty, the dataset
/// will be saved on a subfolder called "data" in the current working directory.</param>
///
public Cifar10(string path = null)
: base(path)
{
// Download and uncompress the Cifar10 dataset
string uncompressedFileName = Download("https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz");
// Unpack the .tar
string destinationFolder = uncompressedFileName.Remove(uncompressedFileName.Length - 4, 4);
using (var inputStream = new FileStream(uncompressedFileName, FileMode.Open, FileAccess.Read))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(inputStream))
{
tarArchive.ExtractContents(destinationFolder);
}
// Load training set
var trainingImages = new List <byte[]>();
var trainingLabels = new List <int>();
parse(destinationFolder, "cifar-10-batches-bin/data_batch_1.bin", trainingImages, trainingLabels);
parse(destinationFolder, "cifar-10-batches-bin/data_batch_2.bin", trainingImages, trainingLabels);
parse(destinationFolder, "cifar-10-batches-bin/data_batch_3.bin", trainingImages, trainingLabels);
parse(destinationFolder, "cifar-10-batches-bin/data_batch_4.bin", trainingImages, trainingLabels);
parse(destinationFolder, "cifar-10-batches-bin/data_batch_5.bin", trainingImages, trainingLabels);
this.Training = Tuple.Create(trainingImages.ToArray(), trainingLabels.ToArray());
// Load testing set
var testingImages = new List <byte[]>();
var testingLabels = new List <int>();
parse(destinationFolder, "cifar-10-batches-bin/test_batch.bin", testingImages, testingLabels);
this.Testing = Tuple.Create(testingImages.ToArray(), testingLabels.ToArray());
}
/// <summary>
/// Extracts the archive.
/// </summary>
/// <param name="inStream">The in stream.</param>
private void ExtractArchive(Stream inStream)
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(inStream))
{
tarArchive.ExtractContents(this.target);
}
}
public override void Run(IEphemeralCluster <EphemeralClusterConfiguration> cluster)
{
var to = Path.Combine(cluster.FileSystem.LocalFolder, "server_metrics.tar.gz");
if (!File.Exists(to))
{
var from = "https://download.elasticsearch.org/demos/machine_learning/gettingstarted/server_metrics.tar.gz";
Console.WriteLine($"Download machine learning sample data from: {from}");
DownloadFile(from, to);
Console.WriteLine($"Downloaded machine learning sample data to: {to}");
}
var directoryTarget = Path.Combine(cluster.FileSystem.LocalFolder, "server_metrics");
if (Directory.Exists(directoryTarget))
{
return;
}
Directory.CreateDirectory(directoryTarget);
Console.WriteLine($"Unzipping machine learning sample data: {to} ...");
using (var inStream = File.OpenRead(to))
using (var gzipStream = new GZipInputStream(inStream))
using (var tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
tarArchive.ExtractContents(directoryTarget);
tarArchive.Close();
}
}
private bool ExtractKcptunFile(string gzArchiveName, string destFolder)
{
try
{
using (Stream stream = File.OpenRead(gzArchiveName))
{
using (Stream gzipStream = new GZipInputStream(stream))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
gzipStream.Close();
stream.Close();
return(true);
}
}
}
}
catch (Exception e)
{
this.log.AppendLog(e.ToString(), Colors.Red);
return(false);
}
}
public void ExtractTarball(string gzArchiveName, string destFolder)
{
using var inStream = File.OpenRead(gzArchiveName);
using var gzipStream = new GZipInputStream(inStream);
using var tarArchive = TarArchive.CreateInputTarArchive(gzipStream, Encoding.UTF8);
tarArchive.ExtractContents(destFolder);
}
public static void Initialize()
{
if (Directory.Exists("geoip") && Directory.Exists("geoip/GeoLite2-City") &&
File.Exists("geoip/GeoLite2-City/GeoLite2-City.mmdb"))
{
return;
}
var request =
WebRequest.Create("http://geolite.maxmind.com/download/geoip/database/GeoLite2-City.tar.gz");
using (var response = request.GetResponse())
{
var maxMindTarGz = response.GetResponseStream();
Stream gzipStream = new GZipInputStream(maxMindTarGz);
var tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents("geoip");
tarArchive.Close();
gzipStream.Close();
maxMindTarGz?.Close();
}
foreach (var dir in Directory.GetDirectories("geoip"))
{
if (dir.Contains("GeoLite2-City"))
{
Directory.Move(dir, "geoip/GeoLite2-City");
}
}
}
public static void ExtractTGZ(String gzArchiveName, String destFolder)
{
string flag = gzArchiveName.Split(Path.DirectorySeparatorChar).Last().Split('.').First() + ".bin";
if (File.Exists(Path.Combine(destFolder, flag)))
{
return;
}
Console.WriteLine($"Extracting.");
Task task = Task.Run(() =>
{
using FileStream inStream = File.OpenRead(gzArchiveName);
using GZipInputStream gzipStream = new GZipInputStream(inStream);
using TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream, Encoding.UTF8);
tarArchive.ExtractContents(destFolder);
});
while (!task.IsCompleted)
{
Thread.Sleep(200);
Console.Write(".");
}
File.Create(Path.Combine(destFolder, flag));
Console.WriteLine("");
Console.WriteLine("Extracting is completed.");
}
public static void Decompress(string directory, string archiveFile)
{
if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
{
var tarfile =
Path.Combine(
directory,
Path.GetFileName(archiveFile) + ".tar.gz");
if (File.Exists(tarfile))
{
File.Delete(tarfile);
}
File.Copy(archiveFile, tarfile);
run(directory, "gunzip", string.Format("-q \"{0}\"", tarfile));
tarfile =
Path.Combine(
Path.GetDirectoryName(tarfile),
Path.GetFileNameWithoutExtension(tarfile));
run(directory, "tar", string.Format("-xvf \"{0}\"", tarfile));
File.Delete(tarfile);
return;
}
var inStream = File.OpenRead(archiveFile);
var gzipStream = new GZipInputStream(inStream);
var tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(directory);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
public void TestMigration()
{
string dir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(dir);
var assembly = Assembly.GetExecutingAssembly();
using (Stream fs = assembly.GetManifestResourceStream("longomatch.tar.gz")) {
using (Stream gzipStream = new GZipInputStream(fs)) {
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream)) {
tarArchive.ExtractContents(dir);
}
}
}
CouchbaseStorageLongoMatch storage = new CouchbaseStorageLongoMatch(dir, "longomatch");
Assert.AreEqual(2, storage.RetrieveAll <Team> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <Dashboard> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <LMProject> ().Count());
Team team = storage.RetrieveAll <Team> ().First();
Assert.DoesNotThrow(team.Load);
Dashboard dashboard = storage.RetrieveAll <Dashboard> ().First();
Assert.DoesNotThrow(dashboard.Load);
LMProject project = storage.RetrieveAll <LMProject> ().First();
Assert.DoesNotThrow(project.Load);
}
public static void EnsureDataFile()
{
const string doneFileName = @"Data\PTB.done";
const string url = @"http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz";
if (!Directory.Exists("Data"))
{
Directory.CreateDirectory("Data");
}
if (!File.Exists(doneFileName))
{
using (var client = new WebClient())
{
Console.WriteLine($"Downloading {url} ...");
client.DownloadFile(url, @"Data\PTB.tgz");
}
Decompress(@"Data\PTB.tgz", @"Data\PTB.tar");
using (var tarFile = File.OpenRead(@"Data\PTB.tar"))
using (var tarArchive = TarArchive.CreateInputTarArchive(tarFile))
{
tarArchive.ExtractContents(@"Data\PTB");
}
using (var doneFile = File.CreateText(doneFileName))
{
doneFile.WriteLine($"{DateTime.Now}");
}
}
}
public async Task GetTar()
{
var ipfs = TestFixture.Ipfs;
var temp = MakeTemp();
try
{
var dir = ipfs.FileSystem.AddDirectoryAsync(temp, true).Result;
var dirid = dir.Id.Encode();
var tar = await ipfs.FileSystem.GetAsync(dir.Id);
var archive = TarArchive.CreateInputTarArchive(tar);
var files = new List <string>();
archive.ProgressMessageEvent += (a, e, m) =>
{
files.Add(e.Name);
};
archive.ListContents();
Assert.AreEqual($"{dirid}", files[0]);
Assert.AreEqual($"{dirid}/alpha.txt", files[1]);
Assert.AreEqual($"{dirid}/beta.txt", files[2]);
Assert.AreEqual($"{dirid}/x", files[3]);
Assert.AreEqual($"{dirid}/x/x.txt", files[4]);
Assert.AreEqual($"{dirid}/x/y", files[5]);
Assert.AreEqual($"{dirid}/x/y/y.txt", files[6]);
}
finally
{
Directory.Delete(temp, true);
}
}
/// <summary>
/// Extracts contents of GZipped Tar file to specified directory
/// </summary>
/// <param name="filename">Input .tar.gz file</param>
/// <param name="directory">Output directory</param>
public static void ExtractTar(string filename, string directory)
{
using (Stream inStream = File.OpenRead(filename))
using (Stream gzipStream = new GZipInputStream(inStream))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
tarArchive.ExtractContents(directory);
}
private void UnpackSourcePackage()
{
if (Directory.Exists(CompileDir))
{
Directory.Delete(CompileDir, true);
}
Directory.CreateDirectory(CompileDir);
try
{
using (var fs = File.OpenRead(sourceFile))
{
using (var gzipStream = new GZipInputStream(fs))
{
using (var tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
tarArchive.ExtractContents(CompileDir);
tarArchive.Close();
}
}
}
}
catch (Exception ex)
{
/*
* TODO
* unless $?.exitstatus == 0
* raise Bosh::Agent::MessageHandlerError.new(
* "Compile Package Unpack Source Failure (exit code: #{$?.exitstatus})",
* output)
*/
log.Error(ex);
throw;
}
}
public void DockerfileArchiveTar()
{
// Given
var image = new DockerImage("Testcontainers", "Test", "1.0.0");
var expected = new SortedSet <string> {
"Dockerfile", "setup/setup.sh"
};
var actual = new SortedSet <string>();
var dockerFileArchive = new DockerfileArchive("Assets", "Dockerfile", image, TestcontainersSettings.Logger);
// When
using (var tarOut = new FileInfo(dockerFileArchive.Tar()).OpenRead())
{
using (var tarIn = TarArchive.CreateInputTarArchive(tarOut, Encoding.UTF8))
{
tarIn.ProgressMessageEvent += (_, entry, _) => actual.Add(entry.Name);
tarIn.ListContents();
}
}
// Then
Assert.Equal(expected, actual);
}
private static void PreallocDBFiles(string installDir)
{
try
{
Logger.Debug("Stopping DB...");
StopService(StationService.MONGO_SERVICE_NAME);
Logger.Debug("DB is stopped");
string journalDir = Path.Combine(installDir, @"MongoDB\Data\DB\journal");
if (Directory.Exists(journalDir))
{
string[] preallocFiles = Directory.GetFiles(journalDir, "prealloc.*");
if (preallocFiles != null && preallocFiles.Length > 0)
{
return;
}
}
Logger.Debug("Extracting prealloc DB files...");
string preallocZip = Path.Combine(installDir, @"MongoDB\Data\DB\mongoPrealloc.tar.gz");
GZipInputStream gzipIn = new GZipInputStream(File.OpenRead(preallocZip));
using (TarArchive tar = TarArchive.CreateInputTarArchive(gzipIn))
{
tar.ExtractContents(Path.Combine(installDir, @"MongoDB\Data\DB"));
}
Logger.Info("Extract prealloc DB files successfully");
}
catch (Exception e)
{
Logger.Warn("Error during extracting prealloc DB files", e);
}
}
