/*******************************************************************
 * 
 * Copyright (C) 2013 Kevin Reverchon
 * This file/program is part of gZFS free software
 * See COPYING file for details
 * 
 *******************************************************************/
package gZFS;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

public class zvol {

	public Hashtable<String,zProperties> zProperties = new Hashtable<String, zProperties>();
	//private zProperties zProperty = new zProperties();
	zvol(){

		Hashtable<Object,Object> permitValueNameVolFS = new Hashtable<Object,Object>();
		permitValueNameVolFS.clear();
		zProperties zPropertyNameVolFS = new zProperties();
		zPropertyNameVolFS.setNameProperty("name");
		zPropertyNameVolFS.setLabelProperty("Name");
		zPropertyNameVolFS.setType("noupdateable");
		zPropertyNameVolFS.setValue("");
		zPropertyNameVolFS.setPermitValue(null);
		zPropertyNameVolFS.setPropertyOf("volandfs");
		zProperties.put("name", zPropertyNameVolFS);

		Hashtable<Object,Object> permitValueType = new Hashtable<Object,Object>();
		permitValueType.clear();
		zProperties zPropertyType = new zProperties();
		zPropertyType.setNameProperty("type");
		zPropertyType.setLabelProperty("Type");
		zPropertyType.setType("noupdateable");
		zPropertyType.setValue("");
		permitValueType.put("volume","volume");
		permitValueType.put("filesystem","filesystem");
		zPropertyType.setPermitValue(permitValueType);
		zPropertyType.setPropertyOf("volandfs");
		zProperties.put("type", zPropertyType);

		Hashtable<Object,Object> permitValueDate = new Hashtable<Object,Object>();
		zProperties zPropertyDate = new zProperties();
		permitValueDate.clear();
		zPropertyDate.setNameProperty("creation");
		zPropertyDate.setLabelProperty("Creation Date");
		zPropertyDate.setType("noupdateable");
		zPropertyDate.setValue("");
		zPropertyDate.setPermitValue(null);
		zPropertyDate.setPropertyOf("volandfs");
		zProperties.put("creation", zPropertyDate);

		Hashtable<Object,Object> permitValueUsed = new Hashtable<Object,Object>();
		zProperties zPropertyUsed = new zProperties();
		permitValueUsed.clear();
		zPropertyUsed.setNameProperty("used");
		zPropertyUsed.setLabelProperty("Used");
		zPropertyUsed.setType("noupdateable");
		zPropertyUsed.setValue("");
		zPropertyUsed.setPermitValue(null);
		zPropertyUsed.setPropertyOf("volandfs");
		zProperties.put("used", zPropertyUsed);
		
		Hashtable<Object,Object> permitValueAvailable = new Hashtable<Object,Object>();
		zProperties zPropertyAvailable = new zProperties();
		permitValueAvailable.clear();
		zPropertyAvailable.setNameProperty("available");
		zPropertyAvailable.setLabelProperty("Available");
		zPropertyAvailable.setType("noupdateable");
		zPropertyAvailable.setValue("");
		zPropertyAvailable.setPermitValue(null);
		zPropertyAvailable.setPropertyOf("fs");
		zProperties.put("available", zPropertyAvailable);

		Hashtable<Object,Object> permitValueCompressRatio = new Hashtable<Object,Object>();
		zProperties zPropertyCompressRatio = new zProperties();
		permitValueCompressRatio.clear();
		zPropertyCompressRatio.setNameProperty("compressratio");
		zPropertyCompressRatio.setLabelProperty("Compression Ratio");
		zPropertyCompressRatio.setType("noupdateable");
		zPropertyCompressRatio.setValue("");
		zPropertyCompressRatio.setPermitValue(null);
		zPropertyCompressRatio.setPropertyOf("volandfs");
		zProperties.put("compressratio", zPropertyCompressRatio);

		Hashtable<Object,Object> permitValueSize = new Hashtable<Object,Object>();
		zProperties zPropertySize = new zProperties();
		permitValueSize.clear();
		zPropertySize.setNameProperty("volsize");
		zPropertySize.setLabelProperty("Volume Size");
		zPropertySize.setType("freeentry");
		zPropertySize.setValue("");
		zPropertySize.setPermitValue(null);
		zPropertySize.setPropertyOf("volume");
		zProperties.put("volsize", zPropertySize);

		Hashtable<Object,Object> permitValueSizeVolBlockSize = new Hashtable<Object,Object>();
		zProperties zPropertySizeVolBlockSize = new zProperties();
		permitValueSizeVolBlockSize.clear();
		zPropertySizeVolBlockSize.setNameProperty("volblocksize");
		zPropertySizeVolBlockSize.setLabelProperty("Volume Block Size");
		zPropertySizeVolBlockSize.setType("noupdateable");
		zPropertySizeVolBlockSize.setValue("");
		zPropertySizeVolBlockSize.setPermitValue(null);
		zPropertySizeVolBlockSize.setPropertyOf("volume");
		zProperties.put("volblocksize", zPropertySizeVolBlockSize);

		Hashtable<Object,Object> permitValueCompress = new Hashtable<Object,Object>();
		zProperties zPropertyCompress = new zProperties();
		permitValueCompress.clear();
		zPropertyCompress.setNameProperty("compression");
		zPropertyCompress.setLabelProperty("Compression");
		zPropertyCompress.setType("nofreeentry");
		zPropertyCompress.setValue("off");
		permitValueCompress.put("off","off");
		permitValueCompress.put("on","on");
		zPropertyCompress.setPermitValue(permitValueCompress);
		zPropertyCompress.setPropertyOf("volandfs");
		zProperties.put("compression", zPropertyCompress);

		Hashtable<Object,Object> permitValueReadOnly = new Hashtable<Object,Object>();
		zProperties zPropertyReadOnly = new zProperties();
		permitValueReadOnly.clear();
		zPropertyReadOnly.setNameProperty("readonly");
		zPropertyReadOnly.setLabelProperty("Read Only");
		zPropertyReadOnly.setType("nofreeentry");
		zPropertyReadOnly.setValue("off");
		permitValueReadOnly.put("off","off");
		permitValueReadOnly.put("on","on");
		zPropertyReadOnly.setPermitValue(permitValueReadOnly);
		zPropertyReadOnly.setPropertyOf("volandfs");
		zProperties.put("readonly", zPropertyReadOnly);

		Hashtable<Object,Object> permitValueDedup = new Hashtable<Object,Object>();
		zProperties zPropertyDedup = new zProperties();
		permitValueDedup.clear();
		zPropertyDedup.setNameProperty("dedup");
		zPropertyDedup.setLabelProperty("Deduplication");
		zPropertyDedup.setType("nofreeentry");
		zPropertyDedup.setValue("off");
		permitValueDedup.put("off","off");
		permitValueDedup.put("on","on");
		zPropertyDedup.setPermitValue(permitValueDedup);
		zPropertyDedup.setPropertyOf("volandfs");
		zProperties.put("dedup", zPropertyDedup);

		Hashtable<Object,Object> permitValueCopies = new Hashtable<Object,Object>();
		zProperties zPropertyCopies = new zProperties();
		permitValueCopies.clear();
		zPropertyCopies.setNameProperty("copies");
		zPropertyCopies.setLabelProperty("Copies");
		zPropertyCopies.setType("freeentry");
		zPropertyCopies.setValue("1");
		zPropertyCopies.setPermitValue(null);
		zPropertyCopies.setPropertyOf("volandfs");
		zProperties.put("copies", zPropertyCopies);

		Hashtable<Object,Object> permitValueUsedbysnapshots = new Hashtable<Object,Object>();
		zProperties zPropertyUsedbysnapshots = new zProperties();
		permitValueUsedbysnapshots.clear();
		zPropertyUsedbysnapshots.setNameProperty("usedbysnapshots");
		zPropertyUsedbysnapshots.setLabelProperty("Used By Snapshots");
		zPropertyUsedbysnapshots.setType("noupdateable");
		zPropertyUsedbysnapshots.setValue("");
		zPropertyUsedbysnapshots.setPropertyOf("volandfs");
		zPropertyUsedbysnapshots.setPermitValue(null);
		zProperties.put("usedbysnapshots", zPropertyUsedbysnapshots);

		Hashtable<Object,Object> permitValueUsedbydataset = new Hashtable<Object,Object>();
		zProperties zPropertyUsedbydataset = new zProperties();
		permitValueUsedbydataset.clear();
		zPropertyUsedbydataset.setNameProperty("usedbydataset");
		zPropertyUsedbydataset.setLabelProperty("Used By Dataset");
		zPropertyUsedbydataset.setType("noupdateable");
		zPropertyUsedbydataset.setValue("");
		zPropertyUsedbydataset.setPermitValue(null);
		zPropertyUsedbydataset.setPropertyOf("volandfs");
		zProperties.put("usedbydataset", zPropertyUsedbydataset);

		Hashtable<Object,Object> permitValueSync = new Hashtable<Object,Object>();
		zProperties zPropertySync = new zProperties();
		permitValueSync.clear();
		zPropertySync.setNameProperty("sync");
		zPropertySync.setLabelProperty("sync");
		zPropertySync.setType("nofreeentry");
		zPropertySync.setValue("standard");
		permitValueSync.put("standard","standard");
		permitValueSync.put("always","always");
		permitValueSync.put("disabled","disabled");
		zPropertySync.setPermitValue(permitValueSync);
		zPropertySync.setPropertyOf("volandfs");
		zProperties.put("sync", zPropertySync);

		Hashtable<Object,Object> permitValueSnapdev = new Hashtable<Object,Object>();
		zProperties zPropertySnapdev = new zProperties();
		permitValueSnapdev.clear();
		zPropertySnapdev.setNameProperty("snapdev");
		zPropertySnapdev.setLabelProperty("Snapshot Device");
		zPropertySnapdev.setType("nofreeentry");
		zPropertySnapdev.setValue("visible");
		permitValueSnapdev.put("visible","visible");
		permitValueSnapdev.put("hidden","hidden");
		zPropertySnapdev.setPermitValue(permitValueSnapdev);
		zPropertySnapdev.setPropertyOf("volandfs");
		zProperties.put("snapdev", zPropertySnapdev);

		Hashtable<Object,Object> permitValueMounted = new Hashtable<Object,Object>();
		zProperties zPropertyMounted = new zProperties();
		permitValueMounted.clear();
		zPropertyMounted.setNameProperty("mounted");
		zPropertyMounted.setLabelProperty("Mounted");
		zPropertyMounted.setType("noupdateable");
		zPropertyMounted.setValue("");
		zPropertyMounted.setPermitValue(permitValueMounted);
		zPropertyMounted.setPropertyOf("fs");
		zProperties.put("mounted", zPropertyMounted);

		Hashtable<Object,Object> permitValueQuota = new Hashtable<Object,Object>();
		zProperties zPropertyQuota = new zProperties();
		permitValueQuota.clear();
		zPropertyQuota.setNameProperty("quota");
		zPropertyQuota.setLabelProperty("Quota");
		zPropertyQuota.setType("freeentry");
		zPropertyQuota.setValue("");
		zPropertyQuota.setPermitValue(permitValueQuota);
		zPropertyQuota.setPropertyOf("fs");
		zProperties.put("quota", zPropertyQuota);

		Hashtable<Object,Object> permitValueReservation = new Hashtable<Object,Object>();
		zProperties zPropertyReservation = new zProperties();
		permitValueReservation.clear();
		zPropertyReservation.setNameProperty("reservation");
		zPropertyReservation.setLabelProperty("Reservation");
		zPropertyReservation.setType("freeentry");
		zPropertyReservation.setValue("");
		zPropertyReservation.setPermitValue(permitValueReservation);
		zPropertyReservation.setPropertyOf("fs");
		zProperties.put("reservation", zPropertyReservation);

		Hashtable<Object,Object> permitValueRecordsize = new Hashtable<Object,Object>();
		zProperties zPropertyRecordsize = new zProperties();
		permitValueRecordsize.clear();
		zPropertyRecordsize.setNameProperty("recordsize");
		zPropertyRecordsize.setLabelProperty("Record Size");
		zPropertyRecordsize.setType("noupdateable");
		zPropertyRecordsize.setValue("");
		zPropertyRecordsize.setPermitValue(permitValueRecordsize);
		zPropertyRecordsize.setPropertyOf("fs");
		zProperties.put("recordsize", zPropertyRecordsize);

		Hashtable<Object,Object> permitValueMountpoint = new Hashtable<Object,Object>();
		zProperties zPropertyMountpoint = new zProperties();
		permitValueMountpoint.clear();
		zPropertyMountpoint.setNameProperty("mountpoint");
		zPropertyMountpoint.setLabelProperty("Mount Point");
		zPropertyMountpoint.setType("noupdateable");
		zPropertyMountpoint.setValue("");
		zPropertyMountpoint.setPermitValue(null);
		zPropertyMountpoint.setPropertyOf("fs");
		zProperties.put("mountpoint", zPropertyMountpoint);

		Hashtable<Object,Object> permitValueSharenfs = new Hashtable<Object,Object>();
		zProperties zPropertySharenfs = new zProperties();
		permitValueSharenfs.clear();
		zPropertySharenfs.setNameProperty("sharenfs");
		zPropertySharenfs.setLabelProperty("Share NFS");
		zPropertySharenfs.setType("nofreeentry");
		zPropertySharenfs.setValue("off");
		permitValueSharenfs.put("off","off");
		permitValueSharenfs.put("on","on");
		zPropertySharenfs.setPermitValue(permitValueSharenfs);
		zPropertySharenfs.setPropertyOf("fs");
		zProperties.put("sharenfs", zPropertySharenfs);

		Hashtable<Object,Object> permitValueAtime = new Hashtable<Object,Object>();
		zProperties zPropertyAtime = new zProperties();
		permitValueAtime.clear();
		zPropertyAtime.setNameProperty("atime");
		zPropertyAtime.setLabelProperty("Atime");
		zPropertyAtime.setType("nofreeentry");
		zPropertyAtime.setValue("on");
		permitValueAtime.put("on","on");
		permitValueAtime.put("off","off");
		zPropertyAtime.setPermitValue(permitValueAtime);
		zPropertyAtime.setPropertyOf("fs");
		zProperties.put("atime", zPropertyAtime);

		Hashtable<Object,Object> permitValueDevices = new Hashtable<Object,Object>();
		zProperties zPropertyDevices = new zProperties();
		permitValueDevices.clear();
		zPropertyDevices.setNameProperty("devices");
		zPropertyDevices.setLabelProperty("Devices");
		zPropertyDevices.setType("nofreeentry");
		zPropertyDevices.setValue("on");
		permitValueDevices.put("on","on");
		permitValueDevices.put("off","off");
		zPropertyDevices.setPropertyOf("fs");
		zPropertyDevices.setPermitValue(permitValueDevices);
		zProperties.put("devices", zPropertyDevices);

		Hashtable<Object,Object> permitValueExec = new Hashtable<Object,Object>();
		zProperties zPropertyExec = new zProperties();
		permitValueExec.clear();
		zPropertyExec.setNameProperty("exec");
		zPropertyExec.setLabelProperty("Exec");
		zPropertyExec.setType("nofreeentry");
		zPropertyExec.setValue("on");
		permitValueExec.put("on","on");
		permitValueExec.put("off","off");
		zPropertyExec.setPermitValue(permitValueExec);
		zPropertyExec.setPropertyOf("fs");
		zProperties.put("exec", zPropertyExec);

		Hashtable<Object,Object> permitValueSetuid = new Hashtable<Object,Object>();
		zProperties zPropertySetuid = new zProperties();
		permitValueSetuid.clear();
		zPropertySetuid.setNameProperty("setuid");
		zPropertySetuid.setLabelProperty("Setuid");
		zPropertySetuid.setType("nofreeentry");
		zPropertySetuid.setValue("on");
		permitValueSetuid.put("on","on");
		permitValueSetuid.put("off","off");
		zPropertySetuid.setPermitValue(permitValueSetuid);
		zPropertySetuid.setPropertyOf("fs");
		zProperties.put("setuid", zPropertySetuid);

		Hashtable<Object,Object> permitValueZoned = new Hashtable<Object,Object>();
		zProperties zPropertyZoned = new zProperties();
		permitValueZoned.clear();
		zPropertyZoned.setNameProperty("zoned");
		zPropertyZoned.setLabelProperty("Zoned");
		zPropertyZoned.setType("nofreeentry");
		zPropertyZoned.setValue("off");
		permitValueZoned.put("off","off");
		permitValueZoned.put("on","on");
		zPropertyZoned.setPermitValue(permitValueZoned);
		zPropertyZoned.setPropertyOf("fs");
		zProperties.put("zoned", zPropertyZoned);

		Hashtable<Object,Object> permitValueSnapdir = new Hashtable<Object,Object>();
		zProperties zPropertySnapdir = new zProperties();
		permitValueSnapdir.clear();
		zPropertySnapdir.setNameProperty("snapdir");
		zPropertySnapdir.setLabelProperty("Snapdir");
		zPropertySnapdir.setType("nofreeentry");
		zPropertySnapdir.setValue("visible");
		permitValueSnapdir.put("visible","visible");
		permitValueSnapdir.put("hidden","hidden");
		zPropertySnapdir.setPermitValue(permitValueSnapdir);
		zPropertySnapdir.setPropertyOf("fs");
		zProperties.put("snapdir", zPropertySnapdir);

		Hashtable<Object,Object> permitValueAclinherit = new Hashtable<Object,Object>();
		zProperties zPropertyAclinherit = new zProperties();
		permitValueAclinherit.clear();
		zPropertyAclinherit.setNameProperty("aclinherit");
		zPropertyAclinherit.setLabelProperty("Aclinherit");
		zPropertyAclinherit.setType("nofreeentry");
		zPropertyAclinherit.setValue("restricted");
		permitValueAclinherit.put("restricted","restricted");
		permitValueAclinherit.put("discard","discard");
		permitValueAclinherit.put("noallow","noallow");
		permitValueAclinherit.put("passthrough","passthrough");
		permitValueAclinherit.put("passthrough-x","passthrough-x");
		zPropertyAclinherit.setPermitValue(permitValueAclinherit);
		zPropertyAclinherit.setPropertyOf("fs");
		zProperties.put("aclinherit", zPropertyAclinherit);

		Hashtable<Object,Object> permitValueCanmount = new Hashtable<Object,Object>();
		zProperties zPropertyCanmount = new zProperties();
		permitValueCanmount.clear();
		zPropertyCanmount.setNameProperty("canmount");
		zPropertyCanmount.setLabelProperty("Can Mount");
		zPropertyCanmount.setType("nofreeentry");
		zPropertyCanmount.setValue("on");
		permitValueCanmount.put("on","on");
		permitValueCanmount.put("off","off");
		zPropertyCanmount.setPermitValue(permitValueCanmount);
		zPropertyCanmount.setPropertyOf("fs");
		zProperties.put("canmount", zPropertyCanmount);
		
		Hashtable<Object,Object> permitValueXattr = new Hashtable<Object,Object>();
		zProperties zPropertyXattr = new zProperties();
		permitValueXattr.clear();
		zPropertyXattr.setNameProperty("xattr");
		zPropertyXattr.setLabelProperty("Xattr");
		zPropertyXattr.setType("nofreeentry");
		zPropertyXattr.setValue("on");
		permitValueXattr.put("on","on");
		permitValueXattr.put("off","off");
		zPropertyXattr.setPermitValue(permitValueXattr);
		zPropertyXattr.setPropertyOf("fs");
		zProperties.put("xattr", zPropertyXattr);
		
		Hashtable<Object,Object> permitValueUtf8only = new Hashtable<Object,Object>();
		zProperties zPropertyUtf8only = new zProperties();
		permitValueUtf8only.clear();
		zPropertyUtf8only.setNameProperty("utf8only");
		zPropertyUtf8only.setLabelProperty("Utf8only");
		zPropertyUtf8only.setType("nofreeentry");
		zPropertyUtf8only.setValue("off");
		permitValueUtf8only.put("off","off");
		permitValueUtf8only.put("on","on");
		zPropertyUtf8only.setPermitValue(permitValueUtf8only);
		zPropertyUtf8only.setPropertyOf("fs");
		zProperties.put("utf8only", zPropertyUtf8only);
		
		Hashtable<Object,Object> permitValueNormalization = new Hashtable<Object,Object>();
		zProperties zPropertyNormalization = new zProperties();
		permitValueNormalization.clear();
		zPropertyNormalization.setNameProperty("normalization");
		zPropertyNormalization.setLabelProperty("Normalization");
		zPropertyNormalization.setType("nofreeentry");
		zPropertyNormalization.setValue("none");
		permitValueNormalization.put("none","none");
		permitValueNormalization.put("formC","formC");
		permitValueNormalization.put("formD","formD");
		permitValueNormalization.put("formKC","formKC");
		permitValueNormalization.put("formKD","formKD");
		zPropertyNormalization.setPermitValue(permitValueNormalization);
		zPropertyNormalization.setPropertyOf("fs");
		zProperties.put("normalization", zPropertyNormalization);

		Hashtable<Object,Object> permitValueCasesensitive = new Hashtable<Object,Object>();
		zProperties zPropertyCasesensitive = new zProperties();
		permitValueCasesensitive.clear();
		zPropertyCasesensitive.setNameProperty("casesensitivity");
		zPropertyCasesensitive.setLabelProperty("Case Sensitivity");
		zPropertyCasesensitive.setType("nofreeentry");
		zPropertyCasesensitive.setValue("sensitive");
		permitValueCasesensitive.put("sensitive","sensitive");
		permitValueCasesensitive.put("insensitive","insensitive");
		permitValueCasesensitive.put("mixed","mixed");
		zPropertyCasesensitive.setPermitValue(permitValueCasesensitive);
		zPropertyCasesensitive.setPropertyOf("fs");
		zProperties.put("casesensitivity", zPropertyCasesensitive);
		
		Hashtable<Object,Object> permitValueVscan = new Hashtable<Object,Object>();
		zProperties zPropertyVscan = new zProperties();
		permitValueVscan.clear();
		zPropertyVscan.setNameProperty("vscan");
		zPropertyVscan.setLabelProperty("Vscan");
		zPropertyVscan.setType("nofreeentry");
		zPropertyVscan.setValue("off");
		permitValueVscan.put("off","off");
		permitValueVscan.put("on","on");
		zPropertyVscan.setPermitValue(permitValueVscan);
		zPropertyVscan.setPropertyOf("fs");
		zProperties.put("vscan", zPropertyVscan);
		
		Hashtable<Object,Object> permitValueNbmand = new Hashtable<Object,Object>();
		zProperties zPropertyNbmand = new zProperties();
		permitValueNbmand.clear();
		zPropertyNbmand.setNameProperty("nbmand");
		zPropertyNbmand.setLabelProperty("Non Blocking mandatory locks");
		zPropertyNbmand.setType("nofreeentry");
		zPropertyNbmand.setValue("off");
		permitValueNbmand.put("off","off");
		permitValueNbmand.put("on","on");
		zPropertyNbmand.setPermitValue(permitValueNbmand);
		zPropertyNbmand.setPropertyOf("fs");
		zProperties.put("nbmand", zPropertyNbmand);
		
		Hashtable<Object,Object> permitValueSharesmb = new Hashtable<Object,Object>();
		zProperties zPropertySharesmb = new zProperties();
		permitValueSharesmb.clear();
		zPropertySharesmb.setNameProperty("sharesmb");
		zPropertySharesmb.setLabelProperty("Share SMB");
		zPropertySharesmb.setType("nofreeentry");
		zPropertySharesmb.setValue("off");
		permitValueSharesmb.put("off","off");
		permitValueSharesmb.put("on","on");
		zPropertySharesmb.setPermitValue(permitValueSharesmb);
		zPropertySharesmb.setPropertyOf("fs");
		zProperties.put("sharesmb", zPropertySharesmb);
		
		Hashtable<Object,Object> permitValueOrigin = new Hashtable<Object,Object>();
		zProperties zPropertyOrigin = new zProperties();
		permitValueOrigin.clear();
		zPropertyOrigin.setNameProperty("origin");
		zPropertyOrigin.setLabelProperty("Clone Origin");
		zPropertyOrigin.setType("noupdateable");
		zPropertyOrigin.setValue("");
		zPropertyOrigin.setPermitValue(null);
		zPropertyOrigin.setPropertyOf("volandfs");
		zProperties.put("origin", zPropertyOrigin);
		
		Hashtable<Object,Object> permitValueClone = new Hashtable<Object,Object>();
		zProperties zPropertyClone = new zProperties();
		permitValueClone.clear();
		zPropertyClone.setNameProperty("clone");
		zPropertyClone.setLabelProperty("Clone");
		zPropertyClone.setType("noupdateable");
		zPropertyClone.setValue("");
		zPropertyClone.setPermitValue(null);
		zPropertyClone.setPropertyOf("volandfs");
		zProperties.put("clone", zPropertyClone);
		
		
	}

}