yencode 1.1.5 → 1.2.1

package/src/yencode.cc

@@ -11,6 +11,7 @@
 #include "crc.h"
 
 using namespace v8;
+using namespace RapidYenc;
 
 static void free_buffer(char* data, void* _size) {
 #if !NODE_VERSION_AT_LEAST(0, 11, 0)
@@ -129,7 +130,7 @@ FUNC(Encode) {
 	size_t dest_len = YENC_MAX_SIZE(arg_len, line_size);
 	
 	unsigned char *result = (unsigned char*) malloc(dest_len);
-	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, true);
+	size_t len = encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, true);
 	result = (unsigned char*)realloc(result, len);
 	MARK_EXT_MEM(len);
 	RETURN_VAL( NEW_BUFFER((char*)result, len, free_buffer, (void*)len) );
@@ -164,7 +165,7 @@ FUNC(EncodeTo) {
 	if(node::Buffer::Length(args[1]) < dest_len)
 		RETURN_ERROR("Destination buffer does not have enough space (use `maxSize` to compute required space)");
 	
-	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, true);
+	size_t len = encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, true);
 	RETURN_VAL( Integer::New(ISOLATE len) );
 }
 
@@ -220,7 +221,7 @@ FUNC(EncodeIncr) {
 		result = (unsigned char*) malloc(dest_len);
 	}
 	
-	size_t len = do_encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, false);
+	size_t len = encode(line_size, &col, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, false);
 	
 	SET_OBJ(ret, "written", Integer::New(ISOLATE len));
 	if(allocResult) {
@@ -247,7 +248,7 @@ FUNC(Decode) {
 		isRaw = ARG_TO_BOOL(args[1]);
 	
 	unsigned char *result = (unsigned char*) malloc(arg_len);
-	size_t len = do_decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, NULL);
+	size_t len = decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), result, arg_len, NULL);
 	result = (unsigned char*)realloc(result, len);
 	MARK_EXT_MEM(len);
 	RETURN_VAL( NEW_BUFFER((char*)result, len, free_buffer, (void*)len) );
@@ -271,7 +272,7 @@ FUNC(DecodeTo) {
 	if (args.Length() > 2)
 		isRaw = ARG_TO_BOOL(args[2]);
 	
-	size_t len = do_decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, NULL);
+	size_t len = decode(isRaw, (const unsigned char*)node::Buffer::Data(args[0]), (unsigned char*)node::Buffer::Data(args[1]), arg_len, NULL);
 	RETURN_VAL( Integer::New(ISOLATE len) );
 }
 
@@ -310,7 +311,7 @@ FUNC(DecodeIncr) {
 	
 	if(allocResult) result = (unsigned char*) malloc(arg_len);
 	unsigned char* dp = result;
-	YencDecoderEnd ended = do_decode_end(&sp, &dp, arg_len, &state);
+	YencDecoderEnd ended = RapidYenc::decode_end((const void**)&sp, (void**)&dp, arg_len, &state);
 	size_t len = dp - result;
 	if(allocResult) result = (unsigned char*)realloc(result, len);
 	
@@ -363,7 +364,7 @@ FUNC(CRC32) {
 			RETURN_ERROR("Second argument must be a 4 byte buffer");
 		crc = read_crc32(args[1]);
 	}
-	crc = do_crc32(
+	crc = crc32(
 		(const void*)node::Buffer::Data(args[0]),
 		node::Buffer::Length(args[0]),
 		crc
@@ -383,7 +384,7 @@ FUNC(CRC32Combine) {
 	uint32_t crc1 = read_crc32(args[0]), crc2 = read_crc32(args[1]);
 	size_t len = (size_t)ARG_TO_INT(args[2]);
 	
-	crc1 = do_crc32_combine(crc1, crc2, len);
+	crc1 = crc32_combine(crc1, crc2, len);
 	RETURN_VAL(pack_crc32(ISOLATE crc1));
 }
 
@@ -399,15 +400,55 @@ FUNC(CRC32Zeroes) {
 			RETURN_ERROR("Second argument must be a 4 byte buffer");
 		crc1 = read_crc32(args[1]);
 	}
-	size_t len = (size_t)ARG_TO_INT(args[0]);
-	crc1 = do_crc32_zeros(crc1, len);
+	int len = ARG_TO_INT(args[0]);
+	if(len < 0)
+		crc1 = crc32_unzero(crc1, -len);
+	else
+		crc1 = crc32_zeros(crc1, len);
 	RETURN_VAL(pack_crc32(ISOLATE crc1));
 }
 
+FUNC(CRC32Multiply) {
+	FUNC_START;
+	
+	if (args.Length() < 2)
+		RETURN_ERROR("At least 2 arguments required");
+	
+	if (!node::Buffer::HasInstance(args[0]) || node::Buffer::Length(args[0]) != 4
+	|| !node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+		RETURN_ERROR("You must supply a 4 byte Buffer for the first two arguments");
+	
+	uint32_t crc1 = read_crc32(args[0]);
+	uint32_t crc2 = read_crc32(args[1]);
+	crc1 = crc32_multiply(crc1, crc2);
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+FUNC(CRC32Shift) {
+	FUNC_START;
+	
+	if (args.Length() < 1)
+		RETURN_ERROR("At least 1 argument required");
+	
+	uint32_t crc1 = 0x80000000;
+	if (args.Length() >= 2) {
+		if (!node::Buffer::HasInstance(args[1]) || node::Buffer::Length(args[1]) != 4)
+			RETURN_ERROR("Second argument must be a 4 byte buffer");
+		crc1 = read_crc32(args[1]);
+	}
+	int n = ARG_TO_INT(args[0]);
+	if(n < 0)
+		crc1 = crc32_shift(crc1, ~crc32_powmod(-n));
+	else
+		crc1 = crc32_shift(crc1, crc32_powmod(n));
+	RETURN_VAL(pack_crc32(ISOLATE crc1));
+}
+
+
 static void init_all() {
 	encoder_init();
 	decoder_init();
-	crc_init();	
+	crc32_init();	
 }
 
 #if NODE_VERSION_AT_LEAST(10, 7, 0)
@@ -436,6 +477,8 @@ void yencode_init(
 	NODE_SET_METHOD(exports, "crc32", CRC32);
 	NODE_SET_METHOD(exports, "crc32_combine", CRC32Combine);
 	NODE_SET_METHOD(exports, "crc32_zeroes", CRC32Zeroes);
+	NODE_SET_METHOD(exports, "crc32_multiply", CRC32Multiply);
+	NODE_SET_METHOD(exports, "crc32_shift", CRC32Shift);
 	
 #if NODE_VERSION_AT_LEAST(10, 7, 0)
 	uv_once(&init_once, init_all);

package/test/_speedbase.js

@@ -81,12 +81,14 @@ module.exports = {
 			module.exports._benchAsync(fn, cb, trials, []);
 		}, asyncWait);
 	},
-	run: function(name, fn, sz2) {
+	run: function(name, fn, sz2, fn2) {
 		var time = module.exports.bench(fn);
+		var time2 = fn2 ? module.exports.bench(fn2) : null;
 		console.log(
 			(name+'                         ').substring(0, 25) + ':'
 			+ fmtSpeed(sz*rounds, time)
-			+ (sz2 ? (' ' + fmtSpeed(sz2*rounds, time)) : '')
+			+ ' ' + (sz2 ? fmtSpeed(sz2*rounds, time) : '                 ')
+			+ ' ' + (fn2 ? fmtSpeed(sz*rounds, time2) : '                 ')
 		);
 	},
 	

package/test/speeddec.js

@@ -30,7 +30,7 @@ _.bufAvg2x.forEach(function(buf, i) {
 
 _.parseArgs('Syntax: node test/speeddec [-a|--average-only] [{-s|--sleep}=msecs(0)] [{-m|--methods}=clean,raw,rawincr]');
 
-console.log('    Test                     Output rate         Read rate   ');
+console.log('    Test                     Output rate         Read rate      Output + CRC   ');
 
 // warmup
 if(!_.sleep) {
@@ -43,51 +43,60 @@ if(!_.sleep) {
 	});
 }
 
+var decCrc = function(src, raw) {
+	var len = y.decodeTo(src, _.bufTarget, raw);
+	y.crc32(_.bufTarget.slice(0, len));
+};
+var decIncrCrc = function(src) {
+	var out = y.decodeIncr(src, 0, _.bufTarget);
+	y.crc32(_.bufTarget.slice(0, out.written));
+};
+
 setTimeout(function() {
 	if(!_.avgOnly) {
 		if(_.decMethods.clean) {
-			_.run('Clean worst (all escaping)', y.decodeTo.bind(null, mWorst, _.bufTarget), lenWorst);
-			_.run('Clean best (min escaping)',  y.decodeTo.bind(null, mBest, _.bufTarget), lenBest);
-			_.run('Clean pass (no escaping)',  y.decodeTo.bind(null, mBest2, _.bufTarget));
+			_.run('Clean worst (all escaping)', y.decodeTo.bind(null, mWorst, _.bufTarget), lenWorst, decCrc.bind(null, mWorst));
+			_.run('Clean best (min escaping)',  y.decodeTo.bind(null, mBest, _.bufTarget), lenBest, decCrc.bind(null, mBest));
+			_.run('Clean pass (no escaping)',  y.decodeTo.bind(null, mBest2, _.bufTarget), null, decCrc.bind(null, mBest2));
 		}
 		if(_.decMethods.raw) {
-			_.run('Raw worst', y.decodeTo.bind(null, mWorst, _.bufTarget, true), lenWorst);
-			_.run('Raw best',  y.decodeTo.bind(null, mBest, _.bufTarget, true), lenBest);
-			_.run('Raw pass',  y.decodeTo.bind(null, mBest2, _.bufTarget, true));
+			_.run('Raw worst', y.decodeTo.bind(null, mWorst, _.bufTarget, true), lenWorst, decCrc.bind(null, mWorst, true));
+			_.run('Raw best',  y.decodeTo.bind(null, mBest, _.bufTarget, true), lenBest, decCrc.bind(null, mBest, true));
+			_.run('Raw pass',  y.decodeTo.bind(null, mBest2, _.bufTarget, true), null, decCrc.bind(null, mBest2, true));
 		}
 		if(_.decMethods.rawincr) {
-			_.run('Raw-incr worst', y.decodeIncr.bind(null, mWorst, 0, _.bufTarget), lenWorst);
-			_.run('Raw-incr best',  y.decodeIncr.bind(null, mBest, 0, _.bufTarget), lenBest);
-			_.run('Raw-incr pass',  y.decodeIncr.bind(null, mBest2, 0, _.bufTarget));
+			_.run('Raw-incr worst', y.decodeIncr.bind(null, mWorst, 0, _.bufTarget), lenWorst, decIncrCrc.bind(null, mWorst));
+			_.run('Raw-incr best',  y.decodeIncr.bind(null, mBest, 0, _.bufTarget), lenBest, decIncrCrc.bind(null, mBest));
+			_.run('Raw-incr pass',  y.decodeIncr.bind(null, mBest2, 0, _.bufTarget), null, decIncrCrc.bind(null, mBest2));
 		}
 	}
 	
 	if(_.decMethods.clean)
 		mAvg.forEach(function(buf, i) {
-			_.run('Clean random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg[i]);
+			_.run('Clean random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg[i], decCrc.bind(null, buf));
 		});
 	if(_.decMethods.raw)
 		mAvg.forEach(function(buf, i) {
-			_.run('Raw random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg[i]);
+			_.run('Raw random ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg[i], decCrc.bind(null, buf, true));
 		});
 	if(_.decMethods.rawincr) {
 		mAvg.forEach(function(buf, i) {
-			_.run('Raw-incr random ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg[i]);
+			_.run('Raw-incr random ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg[i], decIncrCrc.bind(null, buf));
 		});
 	}
 	
 	if(!_.avgOnly) {
 		if(_.decMethods.clean)
 			mAvg2x.forEach(function(buf, i) {
-				_.run('Clean random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i]);
+				_.run('Clean random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i], decCrc.bind(null, buf));
 			});
 		if(_.decMethods.raw)
 			mAvg2x.forEach(function(buf, i) {
-				_.run('Raw random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg2x[i]);
+				_.run('Raw random 2xEsc ('+i+')',   y.decodeTo.bind(null, buf, _.bufTarget, true), lenAvg2x[i], decCrc.bind(null, buf, true));
 			});
 		if(_.decMethods.rawincr)
 			mAvg2x.forEach(function(buf, i) {
-				_.run('Raw-incr random 2xEsc ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg2x[i]);
+				_.run('Raw-incr random 2xEsc ('+i+')',  y.decodeIncr.bind(null, buf, 0, _.bufTarget), lenAvg2x[i], decIncrCrc.bind(null, buf));
 			});
 	}
 }, _.sleep);

package/test/speedenc.js

@@ -5,7 +5,7 @@ var _ = require('./_speedbase');
 _.parseArgs('Syntax: node test/speedenc [-a|--average-only] [{-s|--sleep}=msecs(0)]');
 
 
-console.log('    Test                       Read rate       Output rate   ');
+console.log('    Test                       Read rate       Output rate        Read + CRC      ');
 
 var lenWorst = y.encodeTo(_.bufWorst, _.bufTarget);
 var lenBest = y.encodeTo(_.bufBest, _.bufTarget);
@@ -13,31 +13,35 @@ var lenAvg = Array(_.bufAvg.length);
 var lenAvg2x = Array(_.bufAvg2x.length);
 
 // warmup
-if(!_.sleep) {
-	_.bufAvg.forEach(function(buf, i) {
-		var p=process.hrtime();
-		for(var j=0;j<_.rounds;j+=1) lenAvg[i] = y.encodeTo(buf, _.bufTarget);
-		var t=process.hrtime(p);
-	});
-	_.bufAvg2x.forEach(function(buf, i) {
-		var p=process.hrtime();
-		for(var j=0;j<_.rounds;j+=1) lenAvg2x[i] = y.encodeTo(buf, _.bufTarget);
-		var t=process.hrtime(p);
-	});
-}
+var initRounds = _.sleep ? 1 : _.rounds;
+_.bufAvg.forEach(function(buf, i) {
+	var p=process.hrtime();
+	for(var j=0;j<initRounds;j+=1) lenAvg[i] = y.encodeTo(buf, _.bufTarget);
+	var t=process.hrtime(p);
+});
+_.bufAvg2x.forEach(function(buf, i) {
+	var p=process.hrtime();
+	for(var j=0;j<initRounds;j+=1) lenAvg2x[i] = y.encodeTo(buf, _.bufTarget);
+	var t=process.hrtime(p);
+});
+
+var encCrc = function(src) {
+	y.encodeTo(src, _.bufTarget);
+	y.crc32(src);
+};
 
 setTimeout(function() {
 	if(!_.avgOnly) {
-		_.run('Worst (all escaping)', y.encodeTo.bind(null, _.bufWorst, _.bufTarget), lenWorst);
-		_.run('Best (no escaping)', y.encodeTo.bind(null, _.bufBest, _.bufTarget), lenBest);
+		_.run('Worst (all escaping)', y.encodeTo.bind(null, _.bufWorst, _.bufTarget), lenWorst, encCrc.bind(null, _.bufWorst));
+		_.run('Best (no escaping)', y.encodeTo.bind(null, _.bufBest, _.bufTarget), lenBest, encCrc.bind(null, _.bufBest));
 	}
 	
 	_.bufAvg.forEach(function(buf, i) {
-		_.run('Random ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg[i]);
+		_.run('Random ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg[i], encCrc.bind(null, buf));
 	});
 	if(!_.avgOnly) {
 		_.bufAvg2x.forEach(function(buf, i) {
-			_.run('Random 2xEsc ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i]);
+			_.run('Random 2xEsc ('+i+')', y.encodeTo.bind(null, buf, _.bufTarget), lenAvg2x[i], encCrc.bind(null, buf));
 		});
 	}
 

package/test/testcrc.js

@@ -14,7 +14,7 @@ var ycrc32 = function(s) {
 };
 var doTest = function(msg, f, test, expected) {
 	if(!Array.isArray(test)) test = [test];
-	test[0] = Buffer(test[0]);
+	if(!Buffer.isBuffer(test[0])) test[0] = Buffer(test[0]);
 	if(!expected && test.length == 1 && f == 'crc32') expected = crc32(test[0]).toString('hex');
 	else if(Buffer.isBuffer(expected)) expected = expected.toString('hex');
 	assert.equal(y[f].apply(null, test).toString('hex'), expected, msg);
@@ -45,6 +45,22 @@ assert.equal(y.crc32_zeroes(1, ycrc32('')).toString('hex'), 'd202ef8d', 'Zeroes-
 assert.equal(y.crc32_zeroes(0, ycrc32('z')).toString('hex'), crc32('z').toString('hex'), 'Zeroes Empty Join');
 assert.equal(y.crc32_zeroes(4, ycrc32('z')).toString('hex'), crc32('z\u0000\u0000\u0000\u0000').toString('hex'), 'Zeroes (4) Join');
 
+assert.equal(y.crc32_zeroes(4, y.crc32_zeroes(-4)).toString('hex'), '00000000', 'Zeroes (-4+4)');
+assert.equal(y.crc32_zeroes(-4, y.crc32_zeroes(4)).toString('hex'), '00000000', 'Zeroes (4-4)');
+assert.equal(y.crc32_zeroes(6, y.crc32_zeroes(-2, ycrc32('z'))).toString('hex'), crc32('z\u0000\u0000\u0000\u0000').toString('hex'), 'Zeroes (-2+6) Join');
+
+
+assert.equal(y.crc32_multiply(Buffer([1,2,3,4]), ycrc32('')).toString('hex'), '00000000', 'Multiply by 0');
+assert.equal(y.crc32_multiply(Buffer([0x80,0,0,0]), Buffer([0x80,0,0,0])).toString('hex'), '80000000', 'Multiply by 1');
+assert.equal(y.crc32_multiply(Buffer([1,2,3,4]), Buffer([5,6,7,8])).toString('hex'), '81e243a3', 'Multiply random');
+
+assert.equal(y.crc32_shift(0).toString('hex'), '80000000', '2^0');
+assert.equal(y.crc32_shift(1).toString('hex'), '40000000', '2^1');
+assert.equal(y.crc32_shift(2).toString('hex'), '20000000', '2^2');
+assert.equal(y.crc32_shift(-1).toString('hex'), 'db710641', '2^-1');
+assert.equal(y.crc32_shift(-1, y.crc32_shift(1)).toString('hex'), '80000000', '2^(1-1)');
+assert.equal(y.crc32_shift(4, y.crc32_shift(-2)).toString('hex'), '20000000', '2^(-2+4)');
+
 
 doTest('Random', 'crc32', 'fj[-oqijnw34-59n26 4345j8yn89032q78t9ab9gabh023quhoiBO Z GEB780a sdasdq2345673-98hq2-9348h-na9we8zdfgh-n9  8qwhn-098');
 doTest('Random Continue', 'crc32', ['KZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM', ycrc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEm')], crc32('BdenbmoBgiB10ZkeUBjrsZV3dg2Da2fhHqU9TMdi69AHhLRck3Nk60YuFBXh6lvtefBpjdTxbeEmsaEmKZSHZ5EDOVAmDdakZZOrGSUGGKSpCJoWH7M0MHy6ohnSzvHY4DjpxXmyfWYJQoJ7tKdNhGcuRVUzrgXM'));

package/test/testcrcfuncs.c

@@ -0,0 +1,53 @@
+// compile with: c++ -O -DYENC_DISABLE_CRCUTIL=1 testcrcfuncs.c ../src/crc.cc ../src/crc_*.cc ../src/platform.cc -o testcrcfuncs
+
+#include <stdint.h>
+#include <stddef.h>
+#include "../src/crc.h"
+#include <assert.h>
+
+int main(void) {
+	crc_init();
+	
+	// test crc32_bytepow
+	
+	assert(crc32_bytepow(0) == 0);
+	assert(crc32_bytepow(1) == 8);
+	assert(crc32_bytepow(2) == 16);
+	assert(crc32_bytepow((1<<29)-1) == 0xfffffff8);
+	assert(crc32_bytepow(1<<29) == 1);
+	assert(crc32_bytepow((1<<29)+1) == 9);
+	
+	uint32_t actual;
+	// just do an exhaustive search, since it's not that slow
+	for(uint64_t i=1<<29; i<((1ULL<<32) + 256); i++) {
+		uint32_t ref = (i*8) % 0xffffffff;
+		actual = crc32_bytepow(i);
+		if(ref == 0)
+			assert(actual == 0 || actual == 0xffffffff);
+		else
+			assert(ref == actual);
+	}
+	
+	assert(crc32_bytepow(1ULL<<60) == 0x80000000);
+	assert(crc32_bytepow(1ULL<<61) == 1);
+	assert(crc32_bytepow(1ULL<<62) == 2);
+	assert(crc32_bytepow(1ULL<<63) == 4);
+	actual = crc32_bytepow(~0ULL);
+	assert(actual == 0 || actual == 0xffffffff);
+	assert(crc32_bytepow(~0ULL -1) == 0xfffffff7);
+	assert(crc32_bytepow((1ULL<<63) -1) == 0xfffffffb);
+	assert(crc32_bytepow((1ULL<<63) +1) == 12);
+	
+	
+	// test crc32_mul2pow
+	assert(crc32_mul2pow(0, 0) == 0);
+	assert(crc32_mul2pow(0, 1) == 1);
+	assert(crc32_mul2pow(1, 0) == 0);
+	assert(crc32_mul2pow(1, 0x80000000) == 0x40000000);
+	assert(crc32_mul2pow(1, 0x40000000) == 0x20000000);
+	assert(crc32_mul2pow(4, 0x80000000) == 0x08000000);
+	assert(crc32_mul2pow(5, 0x80000000) == 0x04000000);
+	assert(crc32_mul2pow(0xffffffff, 123) == 123);
+	
+	return 0;
+}

package/test/testdec.js

@@ -114,6 +114,7 @@ var doTest = function(msg, data, expected) {
 				if(actual != x) {
 					console.log('Actual:', actual);
 					console.log('Expect:', x);
+					console.log('Source:', data.toString('hex'));
 					assert.equal(actual, x, msg + ' (in-situ) [' + i + '/' + j + ' ' + f.l + ']');
 				}
 			});