public static byte[] StripPadding(byte[] input, PaddingType paddingtype, int blocksize)
{
int validBytes = StripPadding(input, input.Length, paddingtype, blocksize);
byte[] buf = new byte[validBytes];
Array.Copy(input, buf, validBytes);
return(buf);
}
public void GetPadding(PaddingType paddingOut)
{
Interop.Actor.GetPadding(SwigCPtr, PaddingType.getCPtr(paddingOut));
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
private int _getOverlayToRemove(int overlayNumber, PaddingType paddingType, int x, int y)
{
if (_fieldMapNumber == 312 && paddingType == PaddingType.Down &&
overlayNumber == 2 && x < 17 && y == 12)
{
return(5);
}
return(-1);
}
public void Conv2D(Tensor kernels, int stride, PaddingType padding, Tensor result)
{
Debug.Assert(Depth == kernels.Depth);
int outputWidth = 0, outputHeight = 0, paddingX = 0, paddingY = 0;
GetPaddingParams(padding, Width, Height, kernels.Width, kernels.Height, stride, out outputHeight, out outputWidth, out paddingX, out paddingY);
Op.Conv2D(this, kernels, stride, paddingX, paddingY, result);
}
public Padding(Tile originalTile, Overlay originalOverlay, List <Overlay> overlayList, PaddingCoords paddingCoords,
PaddingCoords paddingCoordsSelf, PaddingType paddingType)
{
_originalTile = originalTile;
_originalOverlay = originalOverlay;
_overlayList = overlayList;
this.paddingCoords = paddingCoords;
this.paddingCoordsSelf = paddingCoordsSelf;
this.type = paddingType;
}
public Tensor Conv2D(Tensor kernels, int stride, PaddingType padding)
{
int outputWidth = 0, outputHeight = 0, paddingX = 0, paddingY = 0;
GetPaddingParams(padding, Width, Height, kernels.Width, kernels.Height, stride, out outputHeight, out outputWidth, out paddingX, out paddingY);
Tensor result = new Tensor(new Shape(outputWidth, outputHeight, kernels.BatchSize, BatchSize));
Conv2D(kernels, stride, padding, result);
return(result);
}
public void Pool(int filterSize, int stride, PoolType type, PaddingType padding, Tensor result)
{
int outWidth = 0, outHeight = 0, paddingX = 0, paddingY = 0;
GetPaddingParams(padding, Width, Height, filterSize, filterSize, stride, out outHeight, out outWidth, out paddingX, out paddingY);
Debug.Assert(result.Width == outWidth);
Debug.Assert(result.Height == outHeight);
Debug.Assert(result.BatchSize == BatchSize);
Op.Pool(this, filterSize, stride, type, paddingX, paddingY, result);
}
public Tensor Pool(int filterSize, int stride, PoolType type, PaddingType padding)
{
int outWidth = 0, outHeight = 0, paddingX = 0, paddingY = 0;
GetPaddingParams(padding, Width, Height, filterSize, filterSize, stride, out outHeight, out outWidth, out paddingX, out paddingY);
Tensor result = new Tensor(new Shape(outWidth, outHeight, Depth, BatchSize));
Pool(filterSize, stride, type, padding, result);
return(result);
}
public void PaddingTypeConstructorWithParameters()
{
tlog.Debug(tag, $"PaddingTypeConstructorWithParameters START");
var testingTarget = new PaddingType(0.0f, 0.0f, 0.0f, 0.0f);
Assert.IsNotNull(testingTarget, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget, "Should be an instance of PaddingType type.");
testingTarget.Dispose();
tlog.Debug(tag, $"PaddingTypeConstructorWithParameters END (OK)");
}
public void PaddingTypeGetHashCode()
{
tlog.Debug(tag, $"PaddingTypeGetHashCode START");
var testingTarget = new PaddingType();
Assert.IsNotNull(testingTarget, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget, "Should be an instance of PaddingType type.");
Assert.GreaterOrEqual(testingTarget.GetHashCode(), 0, "Should be true");
testingTarget.Dispose();
tlog.Debug(tag, $"PaddingTypeGetHashCode END (OK)");
}
public void AddDataElement(string fieldValue, int length, PaddingType paddingType, char paddingChar) {
string newString = fieldValue;
while (newString.Length < length && paddingType != PaddingType.NoPadding) {
if (paddingType == PaddingType.PadLeft) {
newString = paddingChar + newString;
} else {
newString = newString + paddingChar;
}
}
_dataElements.Add(StringUtils.Left(newString, length));
}
public void PaddingTypeStart()
{
tlog.Debug(tag, $"PaddingTypeStart START");
var testingTarget = new PaddingType();
Assert.IsNotNull(testingTarget, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget, "Should be an instance of PaddingType type.");
testingTarget.Start = 20.0f;
Assert.AreEqual(20.0f, testingTarget.Start, "Should be equal!");
testingTarget.Dispose();
tlog.Debug(tag, $"PaddingTypeStart END (OK)");
}
/// <summary>
/// Converts a value into a byte array using the specified data format
/// and returns the number of bytes written.
/// </summary>
/// <exception cref="SerializationException">
/// Thrown if the type is not serializable.
/// </exception>
public static int Write <T>(T obj, FileFormat fmt, out byte[] data,
bool bigEndian = false,
PaddingType padding = PaddingType.Default, byte[] paddingBytes = null)
{
using (DataBuffer stream = new DataBuffer()
{
BigEndian = bigEndian,
PaddingType = padding,
PaddingBytes = paddingBytes
})
{
int bytesWritten = stream.GenericWrite(obj, fmt);
data = stream.GetBuffer();
return(bytesWritten);
}
}
public void PaddingTypeSet()
{
tlog.Debug(tag, $"PaddingTypeSet START");
var testingTarget = new PaddingType();
Assert.IsNotNull(testingTarget, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget, "Should be an instance of PaddingType type.");
testingTarget.Set(0.0f, 0.0f, 20.0f, 30.0f);
Assert.AreEqual(testingTarget.Start, 0.0f, "should be equal.");
Assert.AreEqual(testingTarget.End, 0.0f, "should be equal.");
Assert.AreEqual(testingTarget.Top, 20.0f, "should be equal.");
Assert.AreEqual(testingTarget.Bottom, 30.0f, "should be equal.");
testingTarget.Dispose();
tlog.Debug(tag, $"PaddingTypeSet END (OK)");
}
public ConvolutionConfig(int[][] matrix, int offset, int factor, PaddingType type)
{
this.matrix = matrix;
if (matrix != null)
{
width = matrix[0].Length;
height = matrix.Length;
}
else
{
width = height = 0;
}
this.offset = offset;
this.factor = factor;
this.paddingType = type;
yRadius = (int)Math.Floor(height / 2.0);
xRadius = (int)Math.Floor(width / 2.0);
}
public Conv3D(int filters, Tuple <int, int, int> kernalSize, int strides = 1, PaddingType padding = PaddingType.Same, Tuple <int, int, int> dialationRate = null,
ActType activation = ActType.Linear, BaseInitializer kernalInitializer = null, BaseRegularizer kernalRegularizer = null,
BaseConstraint kernalConstraint = null, bool useBias = true, BaseInitializer biasInitializer = null, BaseRegularizer biasRegularizer = null, BaseConstraint biasConstraint = null)
: base("conv3d")
{
Filters = filters;
KernalSize = kernalSize;
Strides = strides;
Padding = padding;
DialationRate = dialationRate ?? Tuple.Create(1, 1, 1);
Act = activation;
UseBias = useBias;
KernalInitializer = kernalInitializer ?? new GlorotUniform();
BiasInitializer = biasInitializer ?? new Zeros();
KernalConstraint = kernalConstraint;
BiasConstraint = biasConstraint;
KernalRegularizer = kernalRegularizer;
BiasRegularizer = biasRegularizer;
}
/// <summary>
/// Add padding to the string.
/// </summary>
/// <param name="str">
/// The string.
/// </param>
/// <param name="paddingType">
/// The type of padding to add.
/// </param>
/// <returns>
/// The padded string.
/// </returns>
public static string WithPadding(this string str, PaddingType paddingType)
{
if (str == null)
{
return(null);
}
if (paddingType == PaddingType.Leading)
{
return(" " + str);
}
if (paddingType == PaddingType.Trailing)
{
return(str + " ");
}
return(str);
}
public Conv1D(uint filters, uint kernalSize, uint strides = 1, PaddingType padding = PaddingType.Same, uint dilationRate = 1,
ActivationType activation = ActivationType.Linear, BaseInitializer kernalInitializer = null, BaseRegularizer kernalRegularizer = null,
BaseConstraint kernalConstraint = null, bool useBias = true, BaseInitializer biasInitializer = null, BaseRegularizer biasRegularizer = null,
BaseConstraint biasConstraint = null)
: base("conv1d")
{
Filters = filters;
KernalSize = kernalSize;
Strides = strides;
Padding = padding;
DilationRate = dilationRate;
Activation = activation;
UseBias = useBias;
KernalInitializer = kernalInitializer ?? new GlorotUniform();
BiasInitializer = biasInitializer ?? new Zeros();
KernalConstraint = kernalConstraint;
BiasConstraint = biasConstraint;
KernalRegularizer = kernalRegularizer;
BiasRegularizer = biasRegularizer;
}
public void Equals_CHECK_RETURN_VALUE()
{
tlog.Debug(tag, $"PaddingTypeDispose START");
var testingTarget1 = new PaddingType(0.0f, 0.0f, 20.0f, 30.0f);
Assert.IsNotNull(testingTarget1, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget1, "Should be an instance of PaddingType type.");
var testingTarget2 = new PaddingType(0.0f, 0.0f, 20.0f, 30.0f);
Assert.IsNotNull(testingTarget2, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget2, "Should be an instance of PaddingType type.");
var testingTarget3 = new PaddingType(10.0f, 0.0f, 20.0f, 30.0f);
Assert.IsNotNull(testingTarget3, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget3, "Should be an instance of PaddingType type.");
bool flagTrue = testingTarget1.Equals(testingTarget2);
Assert.IsTrue(flagTrue, "Should be true!");
bool flagFalse = testingTarget1.Equals(testingTarget3);
Assert.IsFalse(flagFalse, "Should be false!");
// object is null
Assert.IsFalse(testingTarget1.Equals(null));
// object is not a PaddingType
using (Size size = new Size(100, 200))
{
Assert.IsFalse(testingTarget1.Equals(size));
}
testingTarget1.Dispose();
testingTarget2.Dispose();
testingTarget3.Dispose();
tlog.Debug(tag, $"PaddingTypeDispose END (OK)");
}
public void PaddingTypeDispose()
{
tlog.Debug(tag, $"PaddingTypeDispose START");
var testingTarget = new PaddingType();
Assert.IsNotNull(testingTarget, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget, "Should be an instance of PaddingType type.");
try
{
testingTarget.Dispose();
}
catch (Exception e)
{
tlog.Error(tag, "Caught Exception" + e.ToString());
LogUtils.Write(LogUtils.DEBUG, LogUtils.TAG, "Caught Exception" + e.ToString());
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"PaddingTypeDispose END (OK)");
}
public Conv2D(int filters,
int[] kernel_size = null,
int[] strides = null,
PaddingType padding = PaddingType.Valid,
DataFormatType?data_format = null,
int[] dilation_rate = null,
IActivationFunction activation = null,
bool use_bias = true,
IWeightInitializer kernel_initializer = null,
IWeightInitializer bias_initializer = null,
IWeightRegularizer kernel_regularizer = null,
IWeightRegularizer bias_regularizer = null,
IWeightRegularizer activity_regularizer = null,
IWeightConstraint kernel_constraint = null,
IWeightConstraint bias_constraint = null,
int?[] input_shape = null)
: base(rank: 2,
filters: filters,
kernel_size: kernel_size,
strides: strides,
padding: padding,
data_format: data_format,
dilation_rate: dilation_rate,
activation: activation,
use_bias: use_bias,
kernel_initializer: kernel_initializer,
bias_initializer: bias_initializer,
kernel_regularizer: kernel_regularizer,
bias_regularizer: bias_regularizer,
activity_regularizer: activity_regularizer,
kernel_constraint: kernel_constraint,
bias_constraint: bias_constraint,
input_shape: input_shape)
{
this.input_spec = new List <InputSpec> {
new InputSpec(ndim: 4)
};
}
public void PaddingTypeEquality()
{
tlog.Debug(tag, $"PaddingTypeEquality START");
var testingTarget1 = new PaddingType(0.0f, 0.0f, 20.0f, 30.0f);
Assert.IsNotNull(testingTarget1, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget1, "Should be an instance of PaddingType type.");
var testingTarget2 = new PaddingType(0.0f, 0.0f, 20.0f, 30.0f);
Assert.IsNotNull(testingTarget2, "Can't create success object PaddingType");
Assert.IsInstanceOf <PaddingType>(testingTarget2, "Should be an instance of PaddingType type.");
bool flag = false;
if (testingTarget1 == testingTarget2)
{
flag = true;
}
Assert.IsTrue(flag, "Should be true!");
// If both are null
PaddingType testingTarget3 = null;
PaddingType testingTarget4 = null;
Assert.IsTrue(testingTarget3 == testingTarget4);
// If one is null, but not both
PaddingType testingTarget5 = null;
Assert.IsFalse(testingTarget5 == testingTarget1);
testingTarget1.Dispose();
testingTarget2.Dispose();
tlog.Debug(tag, $"PaddingTypeEquality END (OK)");
}
public void Padding(PaddingType mode, byte[] seq)
{
byte[] data;
using (DataBuffer wb = new DataBuffer()
{
PaddingType = mode, PaddingBytes = seq
})
{
wb.Pad(100);
data = wb.GetBuffer();
Assert.True(data.Length > 0);
}
switch (mode)
{
case PaddingType.Zero:
{
Assert.Equal(0, data.Sum(x => x));
break;
}
case PaddingType.Random:
{
Assert.NotEqual(0, data.Sum(x => x));
break;
}
case PaddingType.Pattern:
{
for (int i = 0; i < data.Length; i++)
{
Assert.Equal(seq[i % seq.Length], data[i]);
}
break;
}
}
}
internal static void GetPaddingParams(PaddingType type, int width, int height, int kernelWidth, int kernelHeight, int stride, out int outHeight, out int outWidth, out int paddingX, out int paddingY)
{
if (type == PaddingType.Valid)
{
outWidth = (int)Math.Floor((width - kernelWidth) / (float)stride + 1);
outHeight = (int)Math.Floor((height - kernelHeight) / (float)stride + 1);
paddingX = 0;
paddingY = 0;
}
else if (type == PaddingType.Same)
{
outWidth = width / stride;
outHeight = height / stride;
paddingX = (int)Math.Floor((float)kernelWidth / 2);
paddingY = (int)Math.Floor((float)kernelHeight / 2);
}
else //if (type == ConvType.Full)
{
outWidth = (width + (kernelWidth - 1)) / stride;
outHeight = (height + (kernelHeight - 1)) / stride;
paddingX = kernelWidth - 1;
paddingY = kernelHeight - 1;
}
}
/// <summary>
/// Does the location represent a place where an attribute can be created or replaced by a completion?
/// </summary>
/// <param name="location">
/// The XML location.
/// </param>
/// <param name="element">
/// The element whose attribute will be completed.
/// </param>
/// <param name="replaceAttribute">
/// The attribute (if any) that will be replaced by the completion.
/// </param>
/// <param name="needsPadding">
/// An <see cref="PaddingType"/> value indicating what sort of padding (if any) is required before / after the attribute.
/// </param>
/// <param name="onElementWithPath">
/// If specified, the location's element must have the specified path.
/// </param>
/// <returns>
/// <c>true</c>, if the location represents an element that can be replaced by completion; otherwise, <c>false</c>.
/// </returns>
public static bool CanCompleteAttribute(this XmlLocation location, out XSElement element, out XSAttribute replaceAttribute, out PaddingType needsPadding, XSPath onElementWithPath = null)
{
if (location == null)
{
throw new ArgumentNullException(nameof(location));
}
replaceAttribute = null;
needsPadding = PaddingType.None;
XSAttribute attribute;
if (location.IsAttribute(out attribute) && !location.IsValue())
{
element = attribute.Element;
if (location.Position == attribute.Start)
{
// Since we're on an existing attribute, we'll add a new attribute after it.
attribute = null;
needsPadding = PaddingType.Trailing;
}
}
else if (location.IsElementBetweenAttributes(out element))
{
if (element.Attributes.Count > 0)
{
// Check if we're directly before an attribute.
foreach (XSAttribute currentAttribute in element.Attributes)
{
if (location.Position == currentAttribute.End)
{
needsPadding = PaddingType.Leading;
}
else
{
continue;
}
break;
}
}
else if (location.Position == element.NameRange.End) // We're directly after the name.
{
needsPadding = PaddingType.Leading;
}
}
else if (location.IsElement(out element))
{
// Check if we're directly after the name.
if (location.Position != element.NameRange.End)
{
return(false);
}
needsPadding = PaddingType.Leading;
}
else
{
return(false);
}
if (onElementWithPath != null && !element.Path.Matches(onElementWithPath))
{
return(false);
}
replaceAttribute = attribute;
return(true);
}
public void AddDataElement(double fieldValue, int length, int numDecimalPlaces, PaddingType paddingType, char paddingChar) {
AddDataElement(fieldValue.ToString("F" + numDecimalPlaces), length, paddingType, paddingChar);
}
/// <summary>
/// Encrypts/Decrypts using OFB
/// </summary>
/// <param name="blockCipher"></param>
/// <param name="cipherAction"></param>
/// <param name="inputStream"></param>
/// <param name="outputStream"></param>
/// <param name="key"></param>
/// <param name="iv"></param>
/// <param name="padding"></param>
/// <param name="stop"></param>
/// <param name="progressChanged"></param>
/// <param name="lastInputBlock"></param>
/// <param name="blocksize"></param>
public static void ExecuteOFB(BlockCipher blockCipher,
CipherAction cipherAction,
ref ICrypToolStream inputStream,
ref ICrypToolStream outputStream,
byte[] key,
byte[] iv,
PaddingType padding,
ref bool stop,
ProgressChanged progressChanged,
ref byte[] lastInputBlock,
int blocksize = 8)
{
using (CStreamReader reader = inputStream.CreateReader())
{
using (CStreamWriter writer = new CStreamWriter())
{
byte[] lastBlock = iv;
int readcount = 0;
while (reader.Position < reader.Length && !stop)
{
//we always try to read a complete block
byte[] inputBlock = new byte[blocksize];
readcount = 0;
while ((readcount += reader.Read(inputBlock, readcount, blocksize - readcount)) < blocksize &&
reader.Position < reader.Length && !stop)
{
;
}
if (stop)
{
return;
}
//Show progress in UI
progressChanged(reader.Position, reader.Length);
byte[] outputblock = null;
//we read a complete block
if (readcount == blocksize)
{
//Compute XOR with lastblock for OFB mode
if (cipherAction == CipherAction.Encrypt)
{
outputblock = blockCipher(lastBlock, key);
lastBlock = outputblock;
outputblock = XOR(outputblock, inputBlock);
}
else
{
outputblock = blockCipher(lastBlock, key);
lastBlock = outputblock;
outputblock = XOR(outputblock, inputBlock);
}
}
//we read an incomplete block, thus, we are at the end of the stream
else if (readcount > 0)
{
//Compute XOR with lastblock for CFB mode
if (cipherAction == CipherAction.Encrypt)
{
byte[] block = new byte[blocksize];
Array.Copy(inputBlock, 0, block, 0, readcount);
outputblock = blockCipher(lastBlock, key);
outputblock = XOR(outputblock, block);
}
else
{
byte[] block = new byte[blocksize];
Array.Copy(inputBlock, 0, block, 0, readcount);
outputblock = blockCipher(inputBlock, key);
outputblock = XOR(outputblock, lastBlock);
}
}
//check if it is the last block and we decrypt, thus, we have to remove the padding
if (reader.Position == reader.Length && cipherAction == CipherAction.Decrypt && padding != PaddingType.None)
{
int valid = StripPadding(outputblock, blocksize, padding, blocksize);
if (valid != blocksize)
{
byte[] newoutputblock = new byte[valid];
Array.Copy(outputblock, 0, newoutputblock, 0, valid);
outputblock = newoutputblock;
}
else if (valid == 0)
{
outputblock = null;
}
}
//if we crypted something, we output it
if (outputblock != null)
{
writer.Write(outputblock, 0, outputblock.Length);
//if we wrote to the stream, we memorize the last input block for the visualization
lastInputBlock = inputBlock;
}
}
writer.Flush();
outputStream = writer;
}
}
}
public void AddDataElement(int fieldValue, int length, PaddingType paddingType, char paddingChar) {
AddDataElement("" + fieldValue, length, paddingType, paddingChar);
}
public void CanCompleteAttribute(string testFileName, int line, int column, string expectedElementName, PaddingType expectedPadding)
{
Position testPosition = new Position(line, column);
string testXml = LoadTestFile("TestFiles", testFileName + ".xml");
TextPositions positions = new TextPositions(testXml);
XmlDocumentSyntax document = Parser.ParseText(testXml);
XmlLocator locator = new XmlLocator(document, positions);
XmlLocation location = locator.Inspect(testPosition);
Assert.NotNull(location);
XSPath elementPath = XSPath.Parse(expectedElementName);
XSElement element;
XSAttribute replaceAttribute;
PaddingType needsPadding;
Assert.True(
location.CanCompleteAttribute(out element, out replaceAttribute, out needsPadding, onElementWithPath: elementPath),
"CanCompleteAttribute"
);
Assert.NotNull(element);
Assert.Null(replaceAttribute);
Assert.Equal(expectedPadding, needsPadding);
}
public MaxPooling3D(Tuple <uint, uint, uint> poolSize = null, uint strides = 1, PaddingType padding = PaddingType.Same)
: base("maxpooling3d")
{
PoolSize = poolSize ?? Tuple.Create <uint, uint, uint>(2, 2, 2);
Strides = strides;
Padding = padding;
}
/// <summary>
/// Specifies the padding properties for a padding field.
/// </summary>
/// <param name="type">Type of padding the field represents.</param>
/// <param name="length">Length of the padding field.</param>
public PaddingAttribute(PaddingType type, int length)
{
// Initialize fields.
this.Type = type;
this.Length = length;
}
public static ICrypToolStream AppendPadding(ICrypToolStream input, PaddingType paddingtype, int blocksize)
{
return(new CStreamWriter(AppendPadding(StreamToByteArray(input), paddingtype, blocksize)));
}
public static byte[] AppendPadding(byte[] input, PaddingType paddingtype, int blocksize)
{
long l = blocksize - (input.Length % blocksize);
if (paddingtype == PaddingType.None)
{
if (l % blocksize != 0)
{
throw new Exception("Input must be a multiple of blocksize (" + blocksize + " bytes) if no padding is used.");
}
return(input);
}
else if (paddingtype == PaddingType.Zeros)
{
l %= blocksize; // add no zeros if message length is multiple of blocksize
}
byte[] buf = new byte[input.Length + l];
Array.Copy(input, buf, input.Length);
switch (paddingtype)
{
case PaddingType.Zeros:
for (int i = 0; i < l; i++)
{
buf[input.Length + i] = 0x00;
}
break;
case PaddingType.OneZeros:
buf[input.Length] = 0x01;
for (int i = 1; i < l; i++)
{
buf[input.Length + i] = 0x00;
}
break;
case PaddingType.PKCS7:
for (int i = 0; i < l; i++)
{
buf[input.Length + i] = (byte)l;
}
break;
case PaddingType.ISO10126:
Random random = new Random();
for (int i = 0; i < l; i++)
{
buf[input.Length + i] = (byte)random.Next(256);
}
buf[buf.Length - 1] = (byte)l;
break;
case PaddingType.ANSIX923:
for (int i = 0; i < l; i++)
{
buf[input.Length + i] = 0;
}
buf[buf.Length - 1] = (byte)l;
break;
}
return(buf);
}
