bfg-common 1.0.0

package/public/spice-console/application/WorkerProcess_meta.js

@@ -0,0 +1,3103 @@
+/*
+    Copyright (c) 2016 eyeOS
+
+    This file is part of Open365.
+
+    Open365 is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+//Sandboxed script without access to other external functions, objects or anything.
+//used for webworkers.
+//includes: quic and lz_rgb
+
+window = this;
+if (!window['wdi']) {
+	window['wdi'] = {};
+}
+
+window['wdi'].WorkerOperations = {
+	quic: 0,
+	lz_rgb: 1,
+	bytesToUriJpeg: 2,
+	bytesToUriPng: 3
+};
+
+function dispatch(arr, useMessage) {
+
+	var u8 = new Uint8Array(arr);
+	var postMessageW3CCompilant = u8[3];
+
+
+	var result = null;
+	var operation = u8[0];
+
+	if (operation === wdi.WorkerOperations.quic) {
+		try {
+			result = wdi.JSQuic.quic_decode(arr);
+		} catch (e) {
+
+		}
+	} else if (operation === wdi.WorkerOperations.lz_rgb) { //lz?
+		try {
+			result = wdi.LZSS.lz_rgb32_decompress_rgb(arr);
+		} catch (e) {
+
+		}
+	} else if (operation === wdi.WorkerOperations.bytesToUriJpeg) {
+		try {
+			result = bytesToURI(u8, 'jpeg');
+			self.postMessage(result);
+			return; //string is not transferable!
+		} catch (e) {
+
+		}
+	} else if (operation === wdi.WorkerOperations.bytesToUriPng) {
+		try {
+			result = bytesToURI(u8, 'png');
+			self.postMessage(result);
+			return; //string is not transferable!
+		} catch (e) {
+
+		}
+	}
+	if (useMessage && result) {
+
+		if (postMessageW3CCompilant) {
+			self.postMessage(result, [result]);
+		} else {
+			self.postMessage(result);
+		}
+
+	} else {
+		return result;
+	}
+
+}
+
+window['workerDispatch'] = dispatch;
+
+self.addEventListener('message', function(e) {
+	return dispatch(e.data, true);
+}, false);
+
+
+
+//bytes to uri
+function bytesToURI(data, type) {
+	var tmpstr = 'data:image/'+type+',';
+	var len = data.length;
+	for (var i = 4; i < len; i++) {
+		if (data[i] < 16) {
+			tmpstr += '%0';
+		} else {
+			tmpstr += '%';
+		}
+		tmpstr += data[i].toString(16);
+	}
+
+	return tmpstr;
+}
+
+
+//quic
+
+
+wdi.QuicImageType = {
+	QUIC_IMAGE_TYPE_INVALID: 0,
+	QUIC_IMAGE_TYPE_GRAY: 1,
+	QUIC_IMAGE_TYPE_RGB16: 2,
+	QUIC_IMAGE_TYPE_RGB24: 3,
+	QUIC_IMAGE_TYPE_RGB32: 4,
+	QUIC_IMAGE_TYPE_RGBA: 5
+};
+
+function bytesToInt16(bytes) {
+	var low = bytes.shift();
+	var high = bytes.shift();
+
+	return high * Math.pow(16, 2) + low;
+}
+
+function bytesToInt32(bytes) {
+	var low = bytesToInt16(bytes);
+	var high = bytesToInt16(bytes);
+
+	return high * Math.pow(16, 4) + low;
+}
+
+wdi.quic = {};
+
+function wdi_quic_QuicFamily() {
+	this.notGRcwlen = [];
+	this.nGRcodewords = [];
+	this.notGRprefixmask = [];
+	this.notGRsuffixlen = [];
+	this.xlatU2L = [];
+	this.xlatL2U = [];
+}
+
+function wdi_quic_s_bucket() {
+	this.pcounters = null;
+	this.bestcode = 0;
+}
+
+function wdi_quic_CommonState() {
+	this.wm_trigger = this;
+	this.encoder = null;
+	this.waitcnt = 0;
+	this.tabrand_seed = wdi.JSQuic.stabrand();
+	this.wmidx = wdi.JSQuic.DEFwmistart;
+	this.wmileft = wdi.JSQuic.wminext;
+	wdi.JSQuic.set_wm_trigger(this);
+
+
+	this.melcstate = 0;
+	this.melclen = wdi.JSQuic.J[0];
+	this.melcorder = (1 << this.melclen) >>> 0;
+}
+
+
+function wdi_quic_FamilyStat() {
+	this.buckets_buf = null;
+	this.buckets_ptrs = null;
+	this.counters = 0;
+}
+
+function wdi_quic_Channel() {
+	this.encoder = null;
+	this.correlate_row_width = 0;
+	this.correlate_row = null;
+
+	this._buckets_ptrs = null;
+
+	this.family_stat_8bpc = new wdi_quic_FamilyStat();
+	this.family_stat_5bpc = new wdi_quic_FamilyStat();
+
+	this.state = new wdi_quic_CommonState();
+	this.oldFirst = 0;
+}
+
+wdi.JSQuic = {
+	QUIC_MAGIC: 1364543811, //"QUIC"
+	MAXNUMCODES: 8,
+
+	DEFevol: 3,
+	MINevol: 0,
+	MAXevol: 5,
+
+	DEFwmistart: 0,
+	MINwmistart: 0,
+
+	DEFmaxclen: 26,
+
+	DEFwmimax: 6,
+
+	DEFwminext: 2048,
+	MINwminext: 1,
+	MAXwminext: 100000000,
+	MAX_CHANNELS: 4,
+
+	wmimax: 6,
+
+	wminext: 2048,
+
+	evol: 3,
+	family_8bpc: new wdi_quic_QuicFamily(),
+	family_5bpc: new wdi_quic_QuicFamily(),
+
+	bppmask: new Int32Array([
+		0x00000000,
+		0x00000001, 0x00000003, 0x00000007, 0x0000000f,
+		0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
+		0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
+		0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
+		0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
+		0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
+		0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
+		0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff
+	]),
+
+	bitat: new Int32Array([
+		0x00000001, 0x00000002, 0x00000004, 0x00000008,
+		0x00000010, 0x00000020, 0x00000040, 0x00000080,
+		0x00000100, 0x00000200, 0x00000400, 0x00000800,
+		0x00001000, 0x00002000, 0x00004000, 0x00008000,
+		0x00010000, 0x00020000, 0x00040000, 0x00080000,
+		0x00100000, 0x00200000, 0x00400000, 0x00800000,
+		0x01000000, 0x02000000, 0x04000000, 0x08000000,
+		0x10000000, 0x20000000, 0x40000000, 0x80000000
+	]),
+
+	TABRAND_TABSIZE: 256,
+	TABRAND_SEEDMASK: 0x0ff,
+
+	tabrand_chaos: new Int32Array([
+		0x02c57542, 0x35427717, 0x2f5a2153, 0x9244f155, 0x7bd26d07, 0x354c6052, 0x57329b28, 0x2993868e,
+		0x6cd8808c, 0x147b46e0, 0x99db66af, 0xe32b4cac, 0x1b671264, 0x9d433486, 0x62a4c192, 0x06089a4b,
+		0x9e3dce44, 0xdaabee13, 0x222425ea, 0xa46f331d, 0xcd589250, 0x8bb81d7f, 0xc8b736b9, 0x35948d33,
+		0xd7ac7fd0, 0x5fbe2803, 0x2cfbc105, 0x013dbc4e, 0x7a37820f, 0x39f88e9e, 0xedd58794, 0xc5076689,
+		0xfcada5a4, 0x64c2f46d, 0xb3ba3243, 0x8974b4f9, 0x5a05aebd, 0x20afcd00, 0x39e2b008, 0x88a18a45,
+		0x600bde29, 0xf3971ace, 0xf37b0a6b, 0x7041495b, 0x70b707ab, 0x06beffbb, 0x4206051f, 0xe13c4ee3,
+		0xc1a78327, 0x91aa067c, 0x8295f72a, 0x732917a6, 0x1d871b4d, 0x4048f136, 0xf1840e7e, 0x6a6048c1,
+		0x696cb71a, 0x7ff501c3, 0x0fc6310b, 0x57e0f83d, 0x8cc26e74, 0x11a525a2, 0x946934c7, 0x7cd888f0,
+		0x8f9d8604, 0x4f86e73b, 0x04520316, 0xdeeea20c, 0xf1def496, 0x67687288, 0xf540c5b2, 0x22401484,
+		0x3478658a, 0xc2385746, 0x01979c2c, 0x5dad73c8, 0x0321f58b, 0xf0fedbee, 0x92826ddf, 0x284bec73,
+		0x5b1a1975, 0x03df1e11, 0x20963e01, 0xa17cf12b, 0x740d776e, 0xa7a6bf3c, 0x01b5cce4, 0x1118aa76,
+		0xfc6fac0a, 0xce927e9b, 0x00bf2567, 0x806f216c, 0xbca69056, 0x795bd3e9, 0xc9dc4557, 0x8929b6c2,
+		0x789d52ec, 0x3f3fbf40, 0xb9197368, 0xa38c15b5, 0xc3b44fa8, 0xca8333b0, 0xb7e8d590, 0xbe807feb,
+		0xbf5f8360, 0xd99e2f5c, 0x372928e1, 0x7c757c4c, 0x0db5b154, 0xc01ede02, 0x1fc86e78, 0x1f3985be,
+		0xb4805c77, 0x00c880fa, 0x974c1b12, 0x35ab0214, 0xb2dc840d, 0x5b00ae37, 0xd313b026, 0xb260969d,
+		0x7f4c8879, 0x1734c4d3, 0x49068631, 0xb9f6a021, 0x6b863e6f, 0xcee5debf, 0x29f8c9fb, 0x53dd6880,
+		0x72b61223, 0x1f67a9fd, 0x0a0f6993, 0x13e59119, 0x11cca12e, 0xfe6b6766, 0x16b6effc, 0x97918fc4,
+		0xc2b8a563, 0x94f2f741, 0x0bfa8c9a, 0xd1537ae8, 0xc1da349c, 0x873c60ca, 0x95005b85, 0x9b5c080e,
+		0xbc8abbd9, 0xe1eab1d2, 0x6dac9070, 0x4ea9ebf1, 0xe0cf30d4, 0x1ef5bd7b, 0xd161043e, 0x5d2fa2e2,
+		0xff5d3cae, 0x86ed9f87, 0x2aa1daa1, 0xbd731a34, 0x9e8f4b22, 0xb1c2c67a, 0xc21758c9, 0xa182215d,
+		0xccb01948, 0x8d168df7, 0x04238cfe, 0x368c3dbc, 0x0aeadca5, 0xbad21c24, 0x0a71fee5, 0x9fc5d872,
+		0x54c152c6, 0xfc329483, 0x6783384a, 0xeddb3e1c, 0x65f90e30, 0x884ad098, 0xce81675a, 0x4b372f7d,
+		0x68bf9a39, 0x43445f1e, 0x40f8d8cb, 0x90d5acb6, 0x4cd07282, 0x349eeb06, 0x0c9d5332, 0x520b24ef,
+		0x80020447, 0x67976491, 0x2f931ca3, 0xfe9b0535, 0xfcd30220, 0x61a9e6cc, 0xa487d8d7, 0x3f7c5dd1,
+		0x7d0127c5, 0x48f51d15, 0x60dea871, 0xc9a91cb7, 0x58b53bb3, 0x9d5e0b2d, 0x624a78b4, 0x30dbee1b,
+		0x9bdf22e7, 0x1df5c299, 0x2d5643a7, 0xf4dd35ff, 0x03ca8fd6, 0x53b47ed8, 0x6f2c19aa, 0xfeb0c1f4,
+		0x49e54438, 0x2f2577e6, 0xbf876969, 0x72440ea9, 0xfa0bafb8, 0x74f5b3a0, 0x7dd357cd, 0x89ce1358,
+		0x6ef2cdda, 0x1e7767f3, 0xa6be9fdb, 0x4f5f88f8, 0xba994a3a, 0x08ca6b65, 0xe0893818, 0x9e00a16a,
+		0xf42bfc8f, 0x9972eedc, 0x749c8b51, 0x32c05f5e, 0xd706805f, 0x6bfbb7cf, 0xd9210a10, 0x31a1db97,
+		0x923a9559, 0x37a7a1f6, 0x059f8861, 0xca493e62, 0x65157e81, 0x8f6467dd, 0xab85ff9f, 0x9331aff2,
+		0x8616b9f5, 0xedbd5695, 0xee7e29b1, 0x313ac44f, 0xb903112f, 0x432ef649, 0xdc0a36c0, 0x61cf2bba,
+		0x81474925, 0xa8b6c7ad, 0xee5931de, 0xb2f8158d, 0x59fb7409, 0x2e3dfaed, 0x9af25a3f, 0xe1fed4d5
+	]),
+
+	besttrigtab: [
+		[550, 900, 800, 700, 500, 350, 300, 200, 180, 180, 160],
+		[110, 550, 900, 800, 550, 400, 350, 250, 140, 160, 140],
+		[100, 120, 550, 900, 700, 500, 400, 300, 220, 250, 160]
+	],
+
+	lzeroes: new Int32Array([
+		8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	]),
+
+	J: new Int32Array([
+		0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7,
+		7, 8, 9, 10, 11, 12, 13, 14, 15
+	]),
+
+	zeroLUT: null,
+
+	BPC_MASK: {
+		4: 0xff,
+		5: 0xff,
+		24: 0xff,
+		16: 0x1f
+	},
+
+	stabrand: function() {
+		return this.TABRAND_SEEDMASK;
+	},
+
+	tabrand: function(rgb_state) {
+		rgb_state.tabrand_seed++;
+		return this.tabrand_chaos[rgb_state.tabrand_seed & this.TABRAND_SEEDMASK];
+	},
+
+	set_wm_trigger: function(state) {
+		var wm = state.wmidx;
+		if (wm > 10) {
+			wm = 10;
+		}
+
+		//>> 1 == / 2
+		state.wm_trigger = wdi.JSQuic.besttrigtab[Math.floor(wdi.JSQuic.evol >> 1)][wm];
+	},
+
+	ceil_log_2: function(val) {
+		var result;
+
+		if (val === 1) {
+			return 0;
+		}
+
+		result = 1;
+		val -= 1;
+		while ((val >>>= 1)) {
+			result++;
+		}
+
+		return result;
+	},
+
+	decorelate_init: function(family, bpc) {
+		var pixelbitmask = this.bppmask[bpc];
+		var pixelbitmaskshr = pixelbitmask >>> 1;
+		var s;
+
+		for (s = 0; s <= pixelbitmask; s++) {
+			if (s <= pixelbitmaskshr) {
+				family.xlatU2L[s] = (s << 1) >>> 0;
+			} else {
+				family.xlatU2L[s] = (((pixelbitmask - s) << 1) >>> 0) + 1;
+			}
+		}
+	},
+
+	corelate_init: function(family, bpc) {
+		var pixelbitmask = this.bppmask[bpc];
+		var s;
+
+		for (s = 0; s <= pixelbitmask; s++) {
+			if (s & 0x01) {
+				family.xlatL2U[s] = pixelbitmask - (s >>> 1);
+			} else {
+				family.xlatL2U[s] = (s >>> 1);
+			}
+		}
+	},
+
+	family_init: function(family, bpc, limit) {
+		var l;
+
+		for (l = 0; l < bpc; l++) {
+			var altprefixlen, altcodewords;
+
+			altprefixlen = limit - bpc;
+			if (altprefixlen > parseInt(this.bppmask[bpc - l])) {
+				altprefixlen = this.bppmask[bpc - l];
+			}
+
+			altcodewords = this.bppmask[bpc] + 1 - ((altprefixlen << l) >>> 0);
+
+			family.nGRcodewords[l] = ((altprefixlen << l) >>> 0);
+			family.notGRcwlen[l] = altprefixlen + this.ceil_log_2(altcodewords);
+			family.notGRprefixmask[l] = this.bppmask[32 - altprefixlen];
+			family.notGRsuffixlen[l] = this.ceil_log_2(altcodewords);
+		}
+
+		//this.decorelate_init(family, bpc);
+		this.corelate_init(family, bpc);
+	},
+
+	init_zeroLUT: function() {
+
+		this.zeroLUT = new Int32Array(256);
+
+		var i, j, k, l;
+
+		j = k = 1;
+		l = 8;
+		for (i = 0; i < 256; ++i) {
+			this.zeroLUT[i] = l;
+			--k;
+			if (k === 0) {
+				k = j;
+				--l;
+				j *= 2;
+			}
+		}
+	},
+
+	quic_init: function() {
+		this.family_init(this.family_8bpc, 8, this.DEFmaxclen);
+		//this.family_init(this.family_5bpc, 5, this.DEFmaxclen);
+		this.init_zeroLUT();
+
+		//perf improvment
+		wdi.xlatL2U = new Int32Array(this.family_8bpc.xlatL2U.length);
+		wdi.xlatL2U.set(this.family_8bpc.xlatL2U);
+
+		wdi.notGRprefixmask = new Int32Array(this.family_8bpc.notGRprefixmask.length);
+		wdi.notGRprefixmask.set(this.family_8bpc.notGRprefixmask);
+
+		wdi.nGRcodewords = new Int32Array(this.family_8bpc.nGRcodewords.length);
+		wdi.nGRcodewords.set(this.family_8bpc.nGRcodewords);
+
+
+		wdi.notGRcwlen = new Int32Array(this.family_8bpc.notGRcwlen.length);
+		wdi.notGRcwlen.set(this.family_8bpc.notGRcwlen);
+
+		wdi.notGRsuffixlen = new Int32Array(this.family_8bpc.notGRsuffixlen.length);
+		wdi.notGRsuffixlen.set(this.family_8bpc.notGRsuffixlen);
+
+
+		//prepare precomputed lzeroes tables
+		var lzeroes = wdi.JSQuic.lzeroes;
+		var lzeroes8 = new Int32Array(lzeroes);
+		var len = lzeroes.length;
+		for (var i = 0; i < len; i++) {
+			lzeroes8[i] = lzeroes[i] + 8;
+		}
+		wdi.JSQuic.lzeroes8 = lzeroes8;
+
+		//prepare precomputed lzeroes tables
+		var lzeroes16 = new Int32Array(lzeroes);
+		for (var i = 0; i < len; i++) {
+			lzeroes16[i] = lzeroes[i] + 16;
+		}
+		wdi.JSQuic.lzeroes16 = lzeroes16;
+
+		//prepare precomputed lzeroes tables
+		var lzeroes24 = new Int32Array(lzeroes);
+		for (var i = 0; i < len; i++) {
+			lzeroes24[i] = lzeroes[i] + 24;
+		}
+		wdi.JSQuic.lzeroes24 = lzeroes24;
+	},
+
+	quic_image_params: function(encoder, type) {
+		var channels, bpc;
+		switch (type) {
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_GRAY:
+				channels = 1;
+				bpc = 8;
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB16:
+				channels = 3;
+				bpc = 5;
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB24:
+				channels = 3;
+				bpc = 8;
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB32:
+				channels = 3;
+				bpc = 8;
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGBA:
+				channels = 4;
+				bpc = 8;
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_INVALID:
+			default:
+				channels = 0;
+				bpc = 0;
+		}
+		return [channels, bpc];
+	},
+
+	find_model_params: function(encoder, bpc) {
+		var bsize = 0;
+		var bstart = 0;
+		var bend = 0;
+		var repcntr = 0;
+
+		var result = {};
+
+		result.ncounters = 8;
+
+		result.levels = 0x1 << bpc;
+
+		result.n_buckets_ptrs = 0;
+
+		switch (this.evol) {
+			case 1:
+				result.repfirst = 3;
+				result.firstsize = 1;
+				result.repnext = 2;
+				result.mulsize = 2;
+				break;
+			case 3:
+				result.repfirst = 1;
+				result.firstsize = 1;
+				result.repnext = 1;
+				result.mulsize = 2;
+				break;
+			case 5:
+				result.repfirst = 1;
+				result.firstsize = 1;
+				result.repnext = 1;
+				result.mulsize = 4;
+				break;
+			case 0:
+			case 2:
+			case 4:
+			default:
+				wdi.Debug.error('fund model params: invalid evol');
+				return false;
+		}
+
+		result.nbuckets = 0;
+		repcntr = result.repfirst + 1;
+		bsize = result.firstsize;
+
+		do { /* other buckets */
+			if (result.nbuckets) {
+				bstart = bend + 1;
+			} else {
+				bstart = 0;
+			}
+
+			if (!--repcntr) {
+				repcntr = result.repnext;
+				bsize *= result.mulsize;
+			}
+
+			bend = bstart + bsize - 1;
+			if (bend + bsize >= result.levels) {
+				bend = result.levels - 1;
+			}
+
+			if (!result.n_buckets_ptrs) {
+				result.n_buckets_ptrs = result.levels;
+			}
+
+			result.nbuckets++;
+		} while (bend < result.levels - 1);
+		return result;
+	},
+
+	init_model_structures: function(encoder, family, params) {
+		family.buckets_buf = [];
+		for (var i = 0; i < params.nbuckets; i++) {
+			family.buckets_buf[i] = new wdi_quic_s_bucket();
+		}
+		family.buckets_ptrs = [];
+		family.counters = [];
+		this.fill_model_structures(encoder, family, params);
+	},
+
+	fill_model_structures: function(encoder, family, params) {
+		var bsize, bstart, bend = 0,
+			repcntr, bnumber;
+
+		bnumber = 0;
+
+		repcntr = params.repfirst + 1;
+		bsize = params.firstsize;
+
+
+		do {
+			if (bnumber) {
+				bstart = bend + 1;
+			} else {
+				bstart = 0;
+			}
+
+			if (!--repcntr) {
+				repcntr = params.repnext;
+				bsize *= params.mulsize;
+			}
+
+			bend = bstart + bsize - 1;
+			if (bend + bsize >= params.levels) {
+				bend = params.levels - 1;
+			}
+
+			family.buckets_buf[bnumber].pcounters = new Int32Array(params.ncounters);
+			for (var x = 0; x < params.ncounters; x++) {
+				family.buckets_buf[bnumber].pcounters[x] = 0;
+			}
+
+			for (var i = bstart; i <= bend; i++) {
+				family.buckets_ptrs[i] = family.buckets_buf[bnumber];
+			}
+
+
+			bnumber++;
+		} while (bend < params.levels - 1);
+	},
+
+	initChannel: function(encoder, channel) {
+		channel.encoder = encoder;
+		channel.state.encoder = encoder;
+		channel.correlate_row_width = 0;
+		channel.correlate_row = null;
+
+		var params = this.find_model_params(encoder, 8);
+		encoder.n_buckets_8bpc = params.nbuckets;
+		this.init_model_structures(encoder, channel.family_stat_8bpc, params);
+
+		params = this.find_model_params(encoder, 5);
+		encoder.n_buckets_5bpc = params.nbuckets;
+		this.init_model_structures(encoder, channel.family_stat_5bpc, params);
+	},
+
+	encoder_reste_channels: function(encoder, channels, width, bpc) {
+		encoder.num_channels = channels;
+		for (var i = 0; i < channels; i++) {
+			var bucket, end_bucket;
+
+			if (encoder.channels[i].correlate_row_width < width) {
+				encoder.channels[i].correlate_row = new Array(width);
+				encoder.channels[i].correlate_row_width = width;
+			}
+			encoder.channels[i].num_channel = i;
+			if (bpc === 8) {
+				bucket = encoder.channels[i].family_stat_8bpc.buckets_buf;
+				end_bucket = encoder.n_buckets_8bpc;
+				for (var x = 0; x < end_bucket; x++) {
+					bucket[x].bestcode = 8 - 1;
+				}
+				encoder.channels[i]._buckets_ptrs = encoder.channels[i].family_stat_8bpc.buckets_ptrs;
+			} else if (bpc === 5) {
+				bucket = encoder.channels[i].family_stat_5bpc.buckets_buf;
+				end_bucket = encoder.n_buckets_5bpc;
+				for (var x = 0; x < end_bucket; x++) {
+					bucket[x].bestcode = /*BPC*/ 5 - 1;
+				}
+				encoder.channels[i]._buckets_ptrs = encoder.channels[i].family_stat_5bpc.buckets_ptrs;
+			} else {
+				return FALSE;
+			}
+
+			encoder.channels[i].state.waitcnt = 0;
+			encoder.channels[i].state.tabrand_seed = wdi.JSQuic.stabrand();
+			encoder.channels[i].state.wmidx = wdi.JSQuic.DEFwmistart;
+			encoder.channels[i].state.wmileft = wdi.JSQuic.wminext;
+		}
+		return true;
+	},
+
+	decode_channel_run: function(encoder, channel) {
+		var runlen = 0;
+
+		do {
+			var temp, hits;
+			//TODO: casting needed?
+			temp = wdi.JSQuic.zeroLUT[(~(encoder.io_word >>> 24) >>> 0) % 256];
+
+			for (hits = 1; hits <= temp; hits++) {
+				runlen += channel.state.melcorder;
+
+				if (channel.state.melcstate < 32) {
+					channel.state.melclen = wdi.JSQuic.J[++channel.state.melcstate];
+					channel.state.melcorder = (1 << channel.state.melclen) >>> 0;
+				}
+			}
+			if (temp !== 8) {
+				encoder.eatbits(temp + 1, encoder);
+				break;
+			}
+			encoder.eatbits(8, encoder);
+		} while (1);
+
+		/* read the length of the remainder */
+		if (channel.state.melclen) {
+			runlen += encoder.io_word >>> (32 - channel.state.melclen);
+			encoder.eatbits(channel.state.melclen, encoder);
+		}
+
+		/* adjust melcoder parameters */
+		if (channel.state.melcstate) {
+			channel.state.melclen = wdi.JSQuic.J[--channel.state.melcstate];
+			channel.state.melcorder = (1 << channel.state.melclen) >>> 0;
+		}
+
+		return runlen;
+	},
+
+	decode_run: function(encoder) {
+		var runlen = 0;
+		var temp, hits, tempadd;
+		var zeroLUT = wdi.JSQuic.zeroLUT;
+		var rgb_state = encoder.rgb_state;
+		var J = wdi.JSQuic.J;
+		var eatbits = encoder.eatbits;
+		do {
+
+			//TODO: casting needed?
+			temp = zeroLUT[(~(encoder.io_word >>> 24) >>> 0) % 256];
+			tempadd = temp + 1;
+			for (hits = 1; hits < tempadd; hits++) {
+				runlen += encoder.rgb_state.melcorder;
+
+				if (rgb_state.melcstate < 32) {
+					rgb_state.melclen = J[++rgb_state.melcstate];
+					rgb_state.melcorder = (1 << rgb_state.melclen) >>> 0;
+				}
+			}
+			if (temp !== 8) {
+				eatbits(tempadd, encoder);
+				break;
+			}
+			encoder.eatbits(8, encoder);
+		} while (1);
+
+		if (rgb_state.melclen) {
+			runlen += encoder.io_word >>> (32 - rgb_state.melclen);
+			eatbits(rgb_state.melclen, encoder);
+		}
+
+		if (rgb_state.melcstate) {
+			rgb_state.melclen = J[--rgb_state.melcstate];
+			rgb_state.melcorder = (1 << rgb_state.melclen) >>> 0;
+		}
+
+		return runlen;
+	},
+
+	quic_decode: function(data) {
+		//console.time("test");
+		var view = new Uint32Array(data);
+		var encoder = new wdi_quic_Encoder(view);
+		var opaque = encoder.io_word & 0x0000FF00;
+		var format = (encoder.io_word >>> 24) & 0xFF;
+
+
+		encoder.eat32bits(); //skip quic size
+
+		encoder.eat32bits();
+		var magic = encoder.io_word;
+		encoder.eat32bits();
+
+		var version = encoder.io_word;
+		encoder.eat32bits();
+
+		var type = encoder.io_word;
+		encoder.eat32bits();
+
+		encoder.type = type; //here?
+
+		var width = encoder.io_word;
+		encoder.width = width; //here?
+		encoder.eat32bits();
+
+		var height = encoder.io_word;
+		encoder.height = height; //here?
+		encoder.eat32bits();
+
+		var result = wdi.JSQuic.quic_image_params(encoder, type);
+		var channels = result[0];
+		var bpc = result[1];
+
+		this.encoder_reste_channels(encoder, channels, width, bpc);
+
+		var buf = new ArrayBuffer(width * height * 4);
+		var buf8 = new Uint8Array(buf);
+		var data = new Uint32Array(buf);
+		encoder.result = buf8;
+		encoder.resultData = data;
+		encoder.setComputedWidth(width);
+
+		switch (type) {
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB32:
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB24:
+				//ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+				QUIC_UNCOMPRESS_RGB(encoder, channels, bpc, type);
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB16:
+				//				if (type == QUIC_IMAGE_TYPE_RGB16) {
+				//					//ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 2);
+				//					QUIC_UNCOMPRESS_RGB(16, rgb16_pixel_t);
+				//				} else if (type == QUIC_IMAGE_TYPE_RGB32) {
+				//					//ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+				//					QUIC_UNCOMPRESS_RGB(16_to_32, rgb32_pixel_t);
+				//				} else {
+				//					//encoder->usr->warn(encoder->usr, "unsupported output format\n");
+				//					return QUIC_ERROR;
+				//				}
+
+				break;
+			case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGBA:
+				QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type);
+				if (opaque) {
+					var len = buf8.length - 1;
+					while (len > 0) {
+						buf8[len] = 255;
+						len -= 4;
+					}
+				}
+				break;
+				//QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type);
+				//
+				//				if (type != QUIC_IMAGE_TYPE_RGBA) {
+				//					//encoder->usr->warn(encoder->usr, "unsupported output format\n");
+				//					return QUIC_ERROR;
+				//				}
+				//				//ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
+				//				uncompress_rgba(encoder, buf, stride);
+				//				break;
+		}
+		//		var len = encoder.result.length;
+		//		while(len--) {
+		//			imgData.data[len] = encoder.result[len];
+		//		}
+		//console.timeEnd("test");
+
+		//imgData.data.set(buf8);
+		return buf;
+	}
+
+};
+
+wdi.JSQuic.quic_init();
+
+function wdi_quic_Encoder(data) {
+	this.computedWidth = 0;
+	this.result = [];
+	this.cnt = 0;
+	this.pxCnt = 0,
+	this.usr = data;
+	this.type = null;
+	this.width = null;
+	this.height = null;
+	this.num_channels = null;
+
+	this.n_buckets_8bpc = null;
+	this.n_buckets_5bpc = null;
+
+	this.io_available_bits = 32;
+	this.io_now = 0;
+
+	this.io_next_word = null;
+	this.io_now = null;
+
+	this.read_io_word();
+	this.io_word = this.io_next_word;
+
+	this.read_io_word();
+
+	this.io_words_count = data.length;
+
+	this.rows_completed = 0; //??
+
+	this.channels = [];
+
+	this.alphaPos = 3; //first alpha
+
+	this.rgb_state = new wdi_quic_CommonState();
+	for (var i = 0; i < 4; i++) {
+		this.channels[i] = new wdi_quic_Channel();
+		wdi.JSQuic.initChannel(this, this.channels[i]);
+	}
+}
+
+wdi_quic_Encoder.prototype.append = function(databyte) {
+	this.result[this.cnt++] = databyte;
+}
+
+wdi_quic_Encoder.prototype.appendPixel = function(r, g, b) {
+	this.resultData[this.pxCnt++] =
+		(255 << 24) | // alpha
+	(b << 16) | // blue
+	(g << 8) | // green
+	r; // red
+	this.cnt += 4;
+}
+
+wdi_quic_Encoder.prototype.eatbits = function(len, encoder) {
+	var available_bits = encoder.io_available_bits;
+	var io_word = encoder.io_word;
+
+	var delta = available_bits - len;
+
+	io_word = io_word << len;
+
+	//enough bits
+	if (delta >= 0) {
+		io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+		encoder.io_available_bits = delta;
+		encoder.io_word = io_word;
+		return;
+	}
+
+	var io_next_word = encoder.io_next_word;
+	//not enough bits
+	delta = -delta; //bits missing
+	io_word = (io_word | (io_next_word << delta) >>> 0);
+
+	///////////////////
+	//read io word (inlined for perforemance)
+
+	io_next_word = encoder.usr[encoder.io_now++];
+	//end read io_word
+	/////////////////
+
+	available_bits = 32 - delta;
+	io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+	encoder.io_available_bits = available_bits;
+	encoder.io_word = io_word;
+	encoder.io_next_word = io_next_word;
+}
+
+wdi_quic_Encoder.prototype.eat32bits = function() {
+	this.eatbits(16, this);
+	this.eatbits(16, this);
+}
+
+wdi_quic_Encoder.prototype.read_io_word = function() {
+	this.io_next_word = this.usr[this.io_now++];
+}
+
+wdi_quic_Encoder.prototype.row_completed = function() {
+	this.rows_completed++;
+}
+
+wdi_quic_Encoder.prototype.setComputedWidth = function(width) {
+	this.computedWidth = width * 4;
+}
+
+wdi_quic_Encoder.prototype.appendAlpha = function(databyte) {
+	this.result[this.alphaPos] = databyte;
+	this.alphaPos += 4;
+}
+
+function cnt_l_zeroes(bits) {
+	if (bits > 0x007FFFFF) {
+		return wdi.JSQuic.lzeroes[bits >>> 24];
+	} else if (bits > 0x00007FFF) {
+		return 8 + wdi.JSQuic.lzeroes[((bits >>> 16) & 0x000000ff)];
+	} else if (bits > 0x0000007F) {
+		return 16 + wdi.JSQuic.lzeroes[((bits >>> 8) & 0x000000ff)];
+	} else {
+		return 24 + wdi.JSQuic.lzeroes[(bits & 0x000000ff)];
+	}
+}
+
+
+/*
+ *
+ *
+ * JSQUIC FAMILY
+ *
+ *
+ */
+
+function golomb_code_len(n, l) {
+	if (n < wdi.nGRcodewords[l]) {
+		return (n >>> l) + 1 + l;
+	} else {
+		return wdi.notGRcwlen[l];
+	}
+}
+
+function golomb_decoding(l, bits, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen) {
+	var cwlen;
+	var result;
+	//its better to check first for bigger, tested for performance
+	if (bits > notGRprefixmask[l]) {
+		var zeroprefix = cnt_l_zeroes(bits);
+		cwlen = zeroprefix + 1 + l;
+		result = ((zeroprefix << l)) | ((bits >>> (32 - cwlen)) & bppmask[l]);
+	} else {
+		cwlen = notGRcwlen[l];
+		result = nGRcodewords[l] + ((bits) >>> (32 - cwlen) & bppmask[notGRsuffixlen[l]]);
+	}
+	return [result, cwlen];
+}
+
+/* update the bucket using just encoded curval */
+function real_update_model(state, bucket, curval, bpp, wm_trigger) {
+	var i;
+	var bestcode;
+	var bestcodelen;
+	var ithcodelen;
+
+	var pcounters = bucket.pcounters;
+	bestcode = bpp - 1;
+	bestcodelen = (pcounters[bestcode] += golomb_code_len(curval, bestcode));
+
+	for (i = bpp - 2; i >= 0; i--) {
+		ithcodelen = (pcounters[i] += golomb_code_len(curval, i));
+
+		if (ithcodelen < bestcodelen) {
+			bestcode = i;
+			bestcodelen = ithcodelen;
+		}
+	}
+
+	bucket.bestcode = bestcode;
+	if (bestcodelen > state.wm_trigger) {
+		while (bpp-- > 0) {
+			pcounters[bpp] >>>= 1;
+		}
+	}
+}
+
+function UPDATE_MODEL(index, encoder, bpp, correlate_row_r, correlate_row_g, correlate_row_b) {
+	real_update_model(encoder.rgb_state, find_bucket(encoder.channels[0],
+		correlate_row_r[index - 1]), correlate_row_r[index], bpp);
+	real_update_model(encoder.rgb_state, find_bucket(encoder.channels[1],
+		correlate_row_g[index - 1]), correlate_row_g[index], bpp);
+	real_update_model(encoder.rgb_state, find_bucket(encoder.channels[2],
+		correlate_row_b[index - 1]), correlate_row_b[index], bpp);
+}
+
+function find_bucket(channel, val) {
+	if (val === undefined) {
+		val = channel.oldFirst;
+	}
+	return channel._buckets_ptrs[val];
+}
+
+/*
+ *
+ *
+ * JSQUIC RGBA
+ *
+ *
+ */
+
+function QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type) {
+	quic_uncompress_row0(encoder, channels, bpc, type);
+	quic_four_uncompress_row0(encoder, encoder.channels[3], bpc, type);
+	encoder.row_completed();
+	var height = encoder.height;
+	var rgb_state = encoder.rgb_state;
+	for (var row = 1; row < height; row++) {
+		quic_uncompress_row_a(encoder, channels, bpc, type, rgb_state);
+		quic_four_uncompress_row(encoder, encoder.channels[3], bpc, type);
+		encoder.row_completed();
+	}
+}
+
+function quic_four_uncompress_row(encoder, channel, bpc, type) {
+	var bpc_mask = wdi.JSQuic.BPC_MASK[type];
+	var pos = 0;
+	var width = encoder.width;
+	while ((wdi.JSQuic.wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
+		if (channel.state.wmileft) {
+			uncompress_four_row_seg(
+				encoder,
+				channel,
+				pos,
+				pos + channel.state.wmileft,
+				bpc,
+				bpc_mask,
+				type
+			);
+			pos += channel.state.wmileft;
+			width -= channel.state.wmileft;
+		}
+
+		channel.state.wmidx++;
+		wdi.JSQuic.set_wm_trigger(channel.state);
+		channel.state.wmileft = wdi.JSQuic.wminext;
+	}
+
+	if (width) {
+		uncompress_four_row_seg(
+			encoder,
+			channel,
+			pos,
+			pos + width,
+			bpc,
+			bpc_mask,
+			type
+		);
+		if (wdi.JSQuic.wmimax > channel.state.wmidx) {
+			channel.state.wmileft -= width;
+		}
+	}
+}
+
+function uncompress_four_row_seg(encoder, channel, i, end, bpc, bpc_mask, type) {
+	var correlate_row = channel.correlate_row;
+
+	var stopidx = 0;
+
+	var waitmask = wdi.JSQuic.bppmask[channel.state.wmidx];
+
+	var run_index = 0;
+	var run_end = 0;
+
+	var rle = false;
+
+	var computedWidth = encoder.computedWidth;
+
+	var rows_completed = encoder.rows_completed;
+
+	var offset = ((encoder.rows_completed - 1) * computedWidth);
+
+	var data;
+
+	var eatbits = encoder.eatbits;
+	var appendAlpha = encoder.appendAlpha;
+
+	var alpha;
+
+	var ret, codewordlen;
+	var bppmask = wdi.JSQuic.bppmask;
+
+	var notGRprefixmask = wdi.notGRprefixmask;
+	var notGRcwlen = wdi.notGRcwlen;
+	var nGRcodewords = wdi.nGRcodewords;
+	var notGRsuffixlen = wdi.notGRsuffixlen;
+
+	if (!i) {
+		alpha = UNCOMPRESS_ONE_0_A(channel, encoder, bpc_mask, offset);
+
+		if (channel.state.waitcnt) {
+			--channel.state.waitcnt;
+		} else {
+			channel.state.waitcnt = (wdi.JSQuic.tabrand(channel.state) & waitmask);
+			real_update_model(channel.state, find_bucket(channel,
+				correlate_row[-1]), correlate_row[0], bpc);
+		}
+		stopidx = ++i + channel.state.waitcnt;
+	} else {
+		stopidx = i + channel.state.waitcnt;
+		alpha = encoder.result[encoder.alphaPos - 4];
+	}
+
+	for (;;) {
+		while (stopidx < end) {
+			for (; i <= stopidx; i++) {
+				rle = RLE_PRED_A(i, encoder, run_index, computedWidth, rows_completed);
+				if (rle) break;
+
+				ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
+					encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+
+				data = ret[0];
+				codewordlen = ret[1];
+
+				correlate_row[i] = data;
+				alpha = (((wdi.xlatL2U[data] +
+					((alpha + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0);
+
+				appendAlpha.call(encoder, alpha);
+				eatbits(codewordlen, encoder);
+			}
+			if (!rle) {
+				real_update_model(channel.state, find_bucket(channel,
+					correlate_row[stopidx - 1]), correlate_row[stopidx], bpc);
+				stopidx = i + (wdi.JSQuic.tabrand(channel.state) & waitmask);
+			} else {
+				break;
+			}
+		}
+		if (!rle) {
+			for (; i < end; i++) {
+				rle = RLE_PRED_A(i, encoder, run_index, computedWidth, rows_completed);
+				if (rle) break;
+
+				ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
+					encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+
+				data = ret[0];
+				codewordlen = ret[1];
+				correlate_row[i] = data;
+				alpha = (((wdi.xlatL2U[data] +
+					((alpha + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0);
+
+				appendAlpha.call(encoder, alpha);
+				eatbits(codewordlen, encoder);
+			}
+			if (!rle) {
+				channel.state.waitcnt = stopidx - end;
+				return;
+			}
+		}
+
+		//RLE
+		channel.state.waitcnt = stopidx - i;
+		run_index = i;
+		run_end = i + wdi.JSQuic.decode_channel_run(encoder, channel);
+
+		var cpos = ((encoder.rows_completed) * (encoder.width * 4)) + (i * 4);
+		var a = encoder.result[cpos - 1];
+
+		for (; i < run_end; i++) {
+			//TODO: how to append?
+			appendAlpha.call(encoder, a);
+		}
+
+		if (i === end) {
+			return;
+		}
+
+		stopidx = i + channel.state.waitcnt;
+		rle = false;
+		//END RLE
+	}
+}
+
+
+function quic_four_uncompress_row0(encoder, channel, bpc, type) {
+	var bpc_mask = wdi.JSQuic.BPC_MASK[type];
+	var pos = 0;
+	var width = encoder.width;
+	while ((wdi.JSQuic.wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
+		if (channel.state.wmileft) {
+			uncompress_four_row0_seg(
+				encoder,
+				channel,
+				pos,
+				pos + channel.wmileft,
+				wdi.JSQuic.bppmask[channel.state.wmidx],
+				bpc,
+				bpc_mask,
+				type
+			);
+			pos += channel.state.wmileft;
+			width -= channel.state.wmileft;
+		}
+
+		channel.state.wmidx++;
+		wdi.JSQuic.set_wm_trigger(channel.state);
+		channel.state.wmileft = wdi.JSQuic.wminext;
+	}
+
+	if (width) {
+		uncompress_four_row0_seg(
+			encoder,
+			channel,
+			pos,
+			pos + width,
+			wdi.JSQuic.bppmask[channel.state.wmidx],
+			bpc,
+			bpc_mask,
+			type
+		);
+		if (wdi.JSQuic.wmimax > channel.state.wmidx) {
+			channel.state.wmileft -= width;
+		}
+	}
+}
+
+function uncompress_four_row0_seg(encoder, channel, i, end, waitmask, bpc, bpc_mask, type) {
+	var correlate_row = channel.correlate_row;
+
+	var stopidx = 0;
+
+	if (!i) {
+		UNCOMPRESS_ONE_ROW0_0_A(channel);
+
+		if (channel.state.waitcnt) {
+			--channel.state.waitcnt;
+		} else {
+			channel.state.waitcnt = (wdi.JSQuic.tabrand(channel.state) & waitmask);
+			real_update_model(channel.state, find_bucket(channel,
+				correlate_row[-1]), correlate_row[0], bpc);
+		}
+		stopidx = ++i + channel.state.waitcnt;
+	} else {
+		stopidx = i + channel.state.waitcnt;
+	}
+
+	while (stopidx < end) {
+		for (; i <= stopidx; i++) {
+			UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row);
+		}
+		real_update_model(channel.state, find_bucket(channel,
+			correlate_row[stopidx - 1]), correlate_row[stopidx], bpc);
+		stopidx = i + (wdi.JSQuic.tabrand(channel.state) & waitmask);
+	}
+
+	for (; i < end; i++) {
+		UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row);
+	}
+	channel.state.waitcnt = stopidx - end;
+}
+
+function SAME_PIXEL_A(i, result) {
+	if (result[i - 1] === result[i + 3]) {
+		return true;
+	}
+	return false;
+}
+
+function RLE_PRED_A(i, encoder, run_index, width, rows_completed) {
+	var pr = ((rows_completed - 1) * width) + (i * 4); //prev r
+	if (run_index !== i && i > 2) {
+		if (SAME_PIXEL_A(pr, encoder.result)) {
+			pr = ((rows_completed) * width) + ((i - 1) * 4); // cur r
+			if (SAME_PIXEL_A(pr, encoder.result)) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+function UNCOMPRESS_ONE_0_A(channel, encoder, bpc_mask, offset) {
+	var ret, codewordlen;
+	channel.oldFirst = channel.correlate_row[0];
+	ret = golomb_decoding(find_bucket(channel,
+		channel.correlate_row[-1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	channel.correlate_row[0] = ret[0];
+	codewordlen = ret[1];
+	var residuum = wdi.xlatL2U[channel.correlate_row[0]];
+	var prev = PIXEL_B(channel, encoder, 0, offset);
+	var resultpixel = ((residuum + prev) & bpc_mask) >>> 0;
+	encoder.appendAlpha(resultpixel);
+	encoder.eatbits(codewordlen, encoder);
+	return resultpixel;
+}
+
+function UNCOMPRESS_ONE_A(channel, i, bpc_mask, encoder, correlate_row, offset) {
+	var ret, codewordlen;
+	ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
+		encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	var data = ret[0];
+	codewordlen = ret[1];
+	correlate_row[i] = data;
+	encoder.appendAlpha((((wdi.xlatL2U[data] +
+		((PIXEL_A_A(encoder) + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0));
+
+	encoder.eatbits(codewordlen, encoder);
+}
+
+
+function UNCOMPRESS_ONE_ROW0_0_A(channel) {
+	var ret, codewordlen;
+	var encoder = channel.encoder;
+	ret = golomb_decoding(find_bucket(channel, 0).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	channel.correlate_row[0] = ret[0];
+	codewordlen = ret[1];
+	encoder.appendAlpha(wdi.xlatL2U[channel.correlate_row[0]]);
+	encoder.eatbits(codewordlen, encoder);
+}
+
+function UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row) {
+	var ret, codewordlen;
+	ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	var data = ret[0];
+	codewordlen = ret[1];
+	correlate_row[i] = data;
+	encoder.appendAlpha(CORELATE_0_A(encoder, channel, i, bpc_mask, correlate_row));
+	encoder.eatbits(codewordlen, encoder);
+}
+
+function CORELATE_0_A(encoder, channel, curr, bpc_mask, correlate_row) {
+	return ((wdi.xlatL2U[correlate_row[curr]] + PIXEL_A_A(encoder)) & bpc_mask) >>> 0;
+}
+
+function PIXEL_A_A(encoder) {
+	return encoder.result[encoder.alphaPos - 4];
+}
+
+/*
+ *
+ *
+ * JSQUIC UNCOMPRESS
+ *
+ *
+ */
+
+function QUIC_UNCOMPRESS_RGB(encoder, channels, bpc, type) {
+	quic_uncompress_row0(encoder, channels, bpc, type);
+	encoder.row_completed();
+
+	var rgb_state = encoder.rgb_state;
+	var height = encoder.height;
+	var computedAlpha = 255 << 24;
+	var result = encoder.result;
+	var resultData = encoder.resultData;
+	var width = encoder.width;
+	var bpc_mask = wdi.JSQuic.BPC_MASK[type];
+	var jsquic = wdi.JSQuic;
+	var channel_r = encoder.channels[0];
+	var channel_g = encoder.channels[1];
+	var channel_b = encoder.channels[2];
+	var buckets_ptrs_r = channel_r._buckets_ptrs;
+	var buckets_ptrs_g = channel_g._buckets_ptrs;
+	var buckets_ptrs_b = channel_b._buckets_ptrs;
+	var correlate_row_r = channel_r.correlate_row;
+	var correlate_row_g = channel_g.correlate_row;
+	var correlate_row_b = channel_b.correlate_row;
+	var computedWidth = encoder.computedWidth;
+	var xlatL2U = wdi.xlatL2U;
+	var lzeroes = wdi.JSQuic.lzeroes;
+	var lzeroes8 = wdi.JSQuic.lzeroes8;
+	var lzeroes16 = wdi.JSQuic.lzeroes16;
+	var lzeroes24 = wdi.JSQuic.lzeroes24;
+	var notGRprefixmask = wdi.notGRprefixmask;
+	var notGRcwlen = wdi.notGRcwlen;
+	var nGRcodewords = wdi.nGRcodewords;
+	var notGRsuffixlen = wdi.notGRsuffixlen;
+	var eatbits = encoder.eatbits;
+	var tabrand = wdi.JSQuic.tabrand;
+	var decode_run = wdi.JSQuic.decode_run;
+	var bppmask = wdi.JSQuic.bppmask;
+	var jsquic = wdi.JSQuic;
+	var tabrand_chaos = wdi.JSQuic.tabrand_chaos;
+	var tabrand_seedmask = jsquic.TABRAND_SEEDMASK;
+	var usr = encoder.usr;
+
+	for (var row = 1; row < height; row++) {
+		quic_uncompress_row(encoder, channels, bpc, type, rgb_state, computedAlpha, result, resultData, width, bpc_mask,
+			jsquic, channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r,
+			correlate_row_g, correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24,
+			notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, tabrand_chaos,
+			tabrand_seedmask, usr);
+		encoder.rows_completed++;
+	}
+}
+
+
+function quic_uncompress_row(encoder, channels, bpc, type, rgb_state, computedAlpha, result, resultData, width, bpc_mask,
+	jsquic, channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r, correlate_row_g,
+	correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24,
+	notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, tabrand_chaos,
+	tabrand_seedmask, usr) {
+
+	var pos = 0;
+	var rows_completed = encoder.rows_completed;
+	var currentOffset32 = ((rows_completed) * computedWidth / 4);
+	var offset = ((rows_completed - 1) * computedWidth);
+	while ((jsquic.wmimax > rgb_state.wmidx) && (rgb_state.wmileft <= width)) {
+		if (rgb_state.wmileft) {
+			uncompress_row_seg(
+				encoder,
+				pos,
+				pos + rgb_state.wmileft,
+				bpc,
+				bpc_mask,
+				type,
+				rgb_state,
+				computedAlpha,
+				result,
+				resultData,
+				channel_r,
+				channel_g,
+				channel_b,
+				buckets_ptrs_r,
+				buckets_ptrs_g,
+				buckets_ptrs_b,
+				correlate_row_r,
+				correlate_row_g,
+				correlate_row_b,
+				computedWidth,
+				xlatL2U,
+				lzeroes,
+				lzeroes8,
+				lzeroes16,
+				lzeroes24,
+				notGRprefixmask,
+				notGRcwlen,
+				nGRcodewords,
+				notGRsuffixlen,
+				eatbits,
+				tabrand,
+				decode_run,
+				bppmask,
+				jsquic,
+				tabrand_chaos,
+				rows_completed,
+				tabrand_seedmask,
+				offset,
+				currentOffset32,
+				usr
+			);
+			pos += rgb_state.wmileft;
+			width -= rgb_state.wmileft;
+		}
+
+		rgb_state.wmidx++;
+		jsquic.set_wm_trigger(rgb_state);
+		rgb_state.wmileft = jsquic.wminext;
+	}
+
+	if (width) {
+		uncompress_row_seg(
+			encoder,
+			pos,
+			pos + width,
+			bpc,
+			bpc_mask,
+			type,
+			rgb_state,
+			computedAlpha,
+			result,
+			resultData,
+			channel_r,
+			channel_g,
+			channel_b,
+			buckets_ptrs_r,
+			buckets_ptrs_g,
+			buckets_ptrs_b,
+			correlate_row_r,
+			correlate_row_g,
+			correlate_row_b,
+			computedWidth,
+			xlatL2U,
+			lzeroes,
+			lzeroes8,
+			lzeroes16,
+			lzeroes24,
+			notGRprefixmask,
+			notGRcwlen,
+			nGRcodewords,
+			notGRsuffixlen,
+			eatbits,
+			tabrand,
+			decode_run,
+			bppmask,
+			jsquic,
+			tabrand_chaos,
+			rows_completed,
+			tabrand_seedmask,
+			offset,
+			currentOffset32,
+			usr
+		);
+		if (jsquic.wmimax > encoder.rgb_state.wmidx) {
+			rgb_state.wmileft -= width;
+		}
+	}
+}
+
+
+function quic_uncompress_row_a(encoder, channels, bpc, type, rgb_state) {
+	var bpc_mask = wdi.JSQuic.BPC_MASK[type];
+	var pos = 0;
+	var width = encoder.width;
+	while ((wdi.JSQuic.wmimax > rgb_state.wmidx) && (rgb_state.wmileft <= width)) {
+		if (rgb_state.wmileft) {
+			uncompress_row_seg_a(
+				encoder,
+				pos,
+				pos + rgb_state.wmileft,
+				bpc,
+				bpc_mask,
+				type,
+				rgb_state
+			);
+			pos += rgb_state.wmileft;
+			width -= rgb_state.wmileft;
+		}
+
+		rgb_state.wmidx++;
+		wdi.JSQuic.set_wm_trigger(rgb_state);
+		rgb_state.wmileft = wdi.JSQuic.wminext;
+	}
+
+	if (width) {
+		uncompress_row_seg_a(
+			encoder,
+			pos,
+			pos + width,
+			bpc,
+			bpc_mask,
+			type,
+			rgb_state
+		);
+		if (wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) {
+			rgb_state.wmileft -= width;
+		}
+	}
+}
+
+function SAME_PIXEL_RGB_A(i, result) {
+
+	if (result[i - 4] === result[i] && result[i - 3] === result[i + 1] && result[i - 2] === result[i + 2])
+		return true;
+
+	return false;
+}
+
+function SAME_PIXEL(i, result) {
+
+	if (result[i - 1] === result[i])
+		return true;
+
+	return false;
+}
+
+function RLE_PRED_RGB_A(i, encoder, offset, currentOffset, run_index) {
+	if (run_index !== i && i > 2) {
+		if (SAME_PIXEL_RGB_A(offset, encoder.result)) { //fila de arriba
+			var pr = currentOffset + ((i - 1) * 4);
+			if (SAME_PIXEL_RGB_A(pr, encoder.result)) { //pixel de la izquierda
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+function RLE_PRED(i, encoder, offset, currentOffset, run_index) {
+	if (run_index !== i && i > 2) {
+		if (SAME_PIXEL(offset * 4, encoder.result)) { //fila de arriba
+			var pr = currentOffset + i - 1;
+			if (SAME_PIXEL(pr * 4, encoder.result)) { //pixel de la izquierda
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+function uncompress_row_seg(encoder, i, end, bpc, bpc_mask, type, rgb_state, computedAlpha, result, resultData,
+	channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r, correlate_row_g,
+	correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24, notGRprefixmask, notGRcwlen,
+	nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, jsquic, tabrand_chaos, rows_completed,
+	tabrand_seedmask, offset, currentOffset32, usr) {
+
+	var stopidx = 0;
+	var waitmask = bppmask[rgb_state.wmidx];
+	var run_index = 0;
+	var rle = false;
+
+	//var offset = ((rows_completed-1) * computedWidth);
+	//var currentOffset32 = ((rows_completed) * computedWidth/4);
+
+	var i_1, i_4; //for performance improvments
+
+	var pr, pg, pb;
+
+	var prevCorrelatedR, prevCorrelatedG, prevCorrelatedB;
+	var ret, codewordlen, l, bits, zeroprefix;
+
+	var cnt = encoder.cnt;
+	var pxCnt = encoder.pxCnt;
+
+	var prev_row, i4sub, stopidx_sub1;
+
+	var available_bits, io_word, delta, io_next_word;
+
+	if (!i) {
+		pr = UNCOMPRESS_ONE_0(channel_r, encoder, bpc_mask, offset);
+		pg = UNCOMPRESS_ONE_0(channel_g, encoder, bpc_mask, offset);
+		pb = UNCOMPRESS_ONE_0(channel_b, encoder, bpc_mask, offset);
+
+		prevCorrelatedR = correlate_row_r[0];
+		prevCorrelatedG = correlate_row_g[0];
+		prevCorrelatedB = correlate_row_b[0];
+		//inlined appendPixel
+		resultData[pxCnt++] =
+			255 << 24 | // alpha
+		pb << 16 | // blue
+		pg << 8 | // green
+		pr; // red
+		//cnt += 4;
+
+		if (rgb_state.waitcnt) {
+			--rgb_state.waitcnt;
+		} else {
+			rgb_state.waitcnt = (tabrand.call(jsquic, rgb_state) & waitmask);
+			UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+		}
+		stopidx = ++i + rgb_state.waitcnt;
+	} else {
+		stopidx = i + rgb_state.waitcnt;
+		pr = result[cnt - 4];
+		pg = result[cnt - 3];
+		pb = result[cnt - 2];
+
+		prevCorrelatedR = correlate_row_r[i - 1];
+		prevCorrelatedG = correlate_row_g[i - 1];
+		prevCorrelatedB = correlate_row_b[i - 1];
+	}
+
+
+	while (true) {
+		while (stopidx < end) {
+			i_4 = offset + i * 4;
+			for (; i <= stopidx; i++) {
+				/////// critical part
+				//rle = RLE_PRED(i, encoder, ci, currentOffset32, run_index);
+				//RLE_PRED INLINE
+				//inlined same_pixel, see original rle_pred
+				i4sub = i_4 / 4;
+				if (resultData[i4sub - 1] === resultData[i4sub]) { //fila de arriba
+					prev_row = currentOffset32 + i - 1;
+					if (resultData[prev_row - 1] === resultData[prev_row]) { //pixel de la izquierda
+						if (run_index !== i && i > 2) {
+							rle = true;
+							break;
+						}
+					}
+				}
+
+
+				/////////////////////// INLINING UNCOMPRESS_ONE
+				//r
+				/////////////////////// INLINING GOLOMB_DECODING
+				//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_r[prevCorrelatedR].bestcode;
+				bits = encoder.io_word;
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_r[i] = prevCorrelatedR;
+
+				pr = ((((xlatL2U[prevCorrelatedR] +
+					((pr +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//eatbits(codewordlen, encoder);
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+
+				//g
+				///////////////////////////////////////INLINING golomb_decoding
+
+				//ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_g[prevCorrelatedG].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_g[i] = prevCorrelatedG;
+
+				pg = ((((xlatL2U[prevCorrelatedG] +
+					((pg +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+
+				//b
+				////////////////////////////////// INLINING golomb_decoding
+				//ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_b[prevCorrelatedB].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+
+				correlate_row_b[i] = prevCorrelatedB;
+
+				pb = ((((xlatL2U[prevCorrelatedB] +
+					((pb +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+				////////////////////// END INLINING
+
+				/** 
+				pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);	
+				pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
+				pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
+				**/
+
+
+				//this is inlined appendPixel
+				resultData[pxCnt++] =
+					computedAlpha | // alpha
+				pb << 16 | // blue
+				pg << 8 | // green
+				pr; // red
+				//cnt += 4;
+				i_4++; //skip alpha
+			}
+			if (!rle) {
+				//UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+				//inlining update_model
+				stopidx_sub1 = stopidx - 1;
+				real_update_model(rgb_state, buckets_ptrs_r[correlate_row_r[stopidx_sub1]],
+					correlate_row_r[stopidx], bpc);
+				real_update_model(rgb_state, buckets_ptrs_g[correlate_row_g[stopidx_sub1]],
+					correlate_row_g[stopidx], bpc);
+				real_update_model(rgb_state, buckets_ptrs_b[correlate_row_b[stopidx_sub1]],
+					correlate_row_b[stopidx], bpc);
+				//end inlining
+
+				rgb_state.tabrand_seed++;
+				stopidx = i + ((tabrand_chaos[rgb_state.tabrand_seed & tabrand_seedmask]) & waitmask);
+
+
+			} else {
+				break;
+			}
+		}
+
+		if (!rle) {
+			i_4 = offset + i * 4;
+			for (; i < end; i++) {
+				//ci = offset32+i;
+				//rle = RLE_PRED(i, encoder, ci, currentOffset32, run_index);
+				//RLE_PRED INLINE
+				//inlined same_pixel, see original rle_pred
+				i4sub = i_4 / 4;
+				if (resultData[i4sub - 1] === resultData[i4sub]) { //fila de arriba
+					prev_row = currentOffset32 + i - 1;
+					if (resultData[prev_row - 1] === resultData[prev_row]) { //pixel de la izquierda
+						if (run_index !== i && i > 2) {
+							rle = true;
+							break;
+						}
+					}
+				}
+
+				//END INLINE*/
+
+
+				////////////////////// INLINING UNCOMPRESS_ONE
+				//r
+				//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//prevCorrelatedR = ret[0];
+				//codewordlen = ret[1];
+				l = buckets_ptrs_r[prevCorrelatedR].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_r[i] = prevCorrelatedR;
+
+				pr = ((((xlatL2U[prevCorrelatedR] +
+					((pr +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+
+				//g
+				//				ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//				prevCorrelatedG = ret[0];
+				//				codewordlen = ret[1];
+
+				l = buckets_ptrs_g[prevCorrelatedG].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_g[i] = prevCorrelatedG;
+
+				pg = ((((xlatL2U[prevCorrelatedG] +
+					((pg +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+
+				//b
+				//				ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//				prevCorrelatedB = ret[0];
+				//				codewordlen = ret[1];
+				//
+
+				l = buckets_ptrs_b[prevCorrelatedB].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					//zeroprefix = cnt_l_zeroes(bits);
+
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff)];
+					}
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+				correlate_row_b[i] = prevCorrelatedB;
+
+				pb = ((((xlatL2U[prevCorrelatedB] +
+					((pb +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				//INLINING EATBITS
+				available_bits = encoder.io_available_bits;
+				io_word = encoder.io_word;
+
+				delta = available_bits - codewordlen;
+
+				io_word = io_word << codewordlen;
+
+				//enough bits
+				if (delta >= 0) {
+					io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
+					encoder.io_available_bits = delta;
+					encoder.io_word = io_word;
+				} else {
+					io_next_word = encoder.io_next_word;
+					//not enough bits
+					delta = -delta; //bits missing
+					io_word = (io_word | (io_next_word << delta) >>> 0);
+
+					///////////////////
+					//read io word (inlined for perforemance)
+
+					io_next_word = usr[encoder.io_now++];
+					//end read io_word
+					/////////////////
+
+					available_bits = 32 - delta;
+					io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
+
+					encoder.io_available_bits = available_bits;
+					encoder.io_word = io_word;
+					encoder.io_next_word = io_next_word;
+				}
+				//END INLINING
+				///////////////////// END INLINING
+
+				/** 
+				pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);	
+				pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
+				pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
+				**/
+
+				//this is inlined apendPixel
+				resultData[pxCnt++] =
+					(255 << 24) | // alpha
+				(pb << 16) | // blue
+				(pg << 8) | // green
+				pr; // red
+				//cnt += 4;
+				i_4++;
+			}
+			if (!rle) {
+				rgb_state.waitcnt = stopidx - end;
+				encoder.cnt = pxCnt * 4;
+				encoder.pxCnt = pxCnt;
+				return;
+			}
+		}
+
+		///END of critical part
+
+		//RLE
+		rgb_state.waitcnt = stopidx - i;
+		run_index = i;
+		run_end = decode_run(encoder);
+
+		i = run_end + i;
+		while (run_end-- > 0) {
+			//this is inlined appendPixel
+			resultData[pxCnt++] =
+				computedAlpha | // alpha
+			pb << 16 | // blue
+			pg << 8 | // green
+			pr; // red
+			//cnt += 4;
+		}
+
+
+		if (i === end) {
+			encoder.cnt = pxCnt * 4;
+			encoder.pxCnt = pxCnt;
+			return;
+		}
+
+		i_1 = i - 1;
+		prevCorrelatedR = correlate_row_r[i_1];
+		prevCorrelatedG = correlate_row_g[i_1];
+		prevCorrelatedB = correlate_row_b[i_1];
+
+		stopidx = i + rgb_state.waitcnt;
+		rle = false;
+		//END RLE
+	}
+}
+
+function uncompress_row_seg_a(encoder, i, end, bpc, bpc_mask, type, rgb_state) {
+	var channel_r = encoder.channels[0];
+	var channel_g = encoder.channels[1];
+	var channel_b = encoder.channels[2];
+
+	var buckets_ptrs_r = channel_r._buckets_ptrs;
+	var buckets_ptrs_g = channel_g._buckets_ptrs;
+	var buckets_ptrs_b = channel_b._buckets_ptrs;
+
+	var correlate_row_r = channel_r.correlate_row;
+	var correlate_row_g = channel_g.correlate_row;
+	var correlate_row_b = channel_b.correlate_row;
+
+	var stopidx = 0;
+
+	var waitmask = wdi.JSQuic.bppmask[rgb_state.wmidx];
+
+	var run_index = 0;
+	var run_end = 0;
+
+	var rle = false;
+
+	var computedWidth = encoder.computedWidth;
+
+	var offset = ((encoder.rows_completed - 1) * computedWidth);
+	var currentOffset = ((encoder.rows_completed) * computedWidth);
+
+	var offset32 = ((encoder.rows_completed - 1) * computedWidth / 4);
+	var currentOffset32 = ((encoder.rows_completed) * computedWidth / 4);
+
+	var result = encoder.result;
+	var resultData = encoder.resultData;
+
+	var i_1, i_4; //for performance improvments
+
+	var xlatL2U = wdi.xlatL2U;
+
+	var pr, pg, pb;
+
+	var prevCorrelatedR, prevCorrelatedG, prevCorrelatedB;
+
+	var eatbits = encoder.eatbits;
+	var tabrand = wdi.JSQuic.tabrand;
+	var decode_run = wdi.JSQuic.decode_run;
+
+	var ret, codewordlen, l, bits, zeroprefix;
+	var lzeroes = wdi.JSQuic.lzeroes;
+	var lzeroes8 = wdi.JSQuic.lzeroes8;
+	var lzeroes16 = wdi.JSQuic.lzeroes16;
+	var lzeroes24 = wdi.JSQuic.lzeroes24;
+
+	var cnt = encoder.cnt;
+	var pxCnt = encoder.pxCnt;
+
+	var bppmask = wdi.JSQuic.bppmask;
+
+	var notGRprefixmask = wdi.notGRprefixmask;
+	var notGRcwlen = wdi.notGRcwlen;
+	var nGRcodewords = wdi.nGRcodewords;
+	var notGRsuffixlen = wdi.notGRsuffixlen;
+
+	var prev_row, i4sub, ci;
+
+	var computedAlpha = 255 << 24;
+
+	if (!i) {
+		pr = UNCOMPRESS_ONE_0(channel_r, encoder, bpc_mask, offset);
+		pg = UNCOMPRESS_ONE_0(channel_g, encoder, bpc_mask, offset);
+		pb = UNCOMPRESS_ONE_0(channel_b, encoder, bpc_mask, offset);
+
+		prevCorrelatedR = correlate_row_r[0];
+		prevCorrelatedG = correlate_row_g[0];
+		prevCorrelatedB = correlate_row_b[0];
+		//inlined appendPixel
+		resultData[pxCnt++] =
+			(255 << 24) | // alpha
+		(pb << 16) | // blue
+		(pg << 8) | // green
+		pr; // red
+		//cnt += 4;
+
+		if (rgb_state.waitcnt) {
+			--rgb_state.waitcnt;
+		} else {
+			rgb_state.waitcnt = (tabrand.call(wdi.JSQuic, rgb_state) & waitmask);
+			UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+		}
+		stopidx = ++i + rgb_state.waitcnt;
+	} else {
+		stopidx = i + rgb_state.waitcnt;
+		pr = result[cnt - 4];
+		pg = result[cnt - 3];
+		pb = result[cnt - 2];
+
+		prevCorrelatedR = correlate_row_r[i - 1];
+		prevCorrelatedG = correlate_row_g[i - 1];
+		prevCorrelatedB = correlate_row_b[i - 1];
+	}
+
+
+	while (true) {
+		while (stopidx < end) {
+			i_4 = offset + i * 4;
+			for (; i <= stopidx; i++) {
+				/////// critical part
+				rle = RLE_PRED_RGB_A(i, encoder, i_4, currentOffset, run_index);
+				//RLE_PRED INLINE
+				/*if(run_index !== i && i > 2) {
+					//inlined same_pixel, see original rle_pred
+					i4sub = i_4/4;
+					if(encoder.resultData[i4sub-1] === encoder.resultData[i4sub]) { //fila de arriba
+						var prev_row = currentOffset32 + i-1;
+						if(encoder.resultData[prev_row-1] === encoder.resultData[prev_row]) { //pixel de la izquierda
+							rle = true;
+						}
+					}
+				}*/
+				//END INLINE
+				if (rle) break;
+
+
+				/////////////////////// INLINING UNCOMPRESS_ONE
+				//r
+				/////////////////////// INLINING GOLOMB_DECODING
+				//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_r[prevCorrelatedR].bestcode;
+				bits = encoder.io_word;
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_r[i] = prevCorrelatedR;
+
+				pr = ((((xlatL2U[prevCorrelatedR] +
+					((pr +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+
+				//g
+				///////////////////////////////////////INLINING golomb_decoding
+
+				//ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_g[prevCorrelatedG].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_g[i] = prevCorrelatedG;
+
+				pg = ((((xlatL2U[prevCorrelatedG] +
+					((pg +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+
+				//b
+				////////////////////////////////// INLINING golomb_decoding
+				//ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode,
+				//	encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				l = buckets_ptrs_b[prevCorrelatedB].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+
+				correlate_row_b[i] = prevCorrelatedB;
+
+				pb = ((((xlatL2U[prevCorrelatedB] +
+					((pb +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+				////////////////////// END INLINING
+
+				/**
+				pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
+				pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
+				pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
+				**/
+
+
+				//this is inlined appendPixel
+				resultData[pxCnt++] =
+					computedAlpha | // alpha
+				pb << 16 | // blue
+				pg << 8 | // green
+				pr; // red
+				//cnt += 4;
+				i_4++; //skip alpha
+			}
+			if (!rle) {
+				UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+				stopidx = i + (tabrand.call(wdi.JSQuic, rgb_state) & waitmask);
+			} else {
+				break;
+			}
+		}
+
+		if (!rle) {
+			i_4 = offset + i * 4;
+			for (; i < end; i++) {
+				rle = RLE_PRED_RGB_A(i, encoder, i_4, currentOffset, run_index);
+				//RLE_PRED INLINE
+				/*if(run_index !== i && i > 2) {
+					//inlined same_pixel, see original rle_pred
+					i4sub = i_4/4;
+					if(encoder.resultData[i4sub-1] === encoder.resultData[i4sub]) { //fila de arriba
+						var prev_row = currentOffset32 + i-1;
+						if(encoder.resultData[prev_row-1] === encoder.resultData[prev_row]) { //pixel de la izquierda
+							rle = true;
+						}
+					}
+				}
+				//END INLINE*/
+				if (rle) break;
+
+
+				////////////////////// INLINING UNCOMPRESS_ONE
+				//r
+				//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//prevCorrelatedR = ret[0];
+				//codewordlen = ret[1];
+				l = buckets_ptrs_r[prevCorrelatedR].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_r[i] = prevCorrelatedR;
+
+				pr = ((((xlatL2U[prevCorrelatedR] +
+					((pr +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+
+				//g
+				//				ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//				prevCorrelatedG = ret[0];
+				//				codewordlen = ret[1];
+
+				l = buckets_ptrs_g[prevCorrelatedG].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+
+				correlate_row_g[i] = prevCorrelatedG;
+
+				pg = ((((xlatL2U[prevCorrelatedG] +
+					((pg +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+
+				//b
+				//				ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
+				//				prevCorrelatedB = ret[0];
+				//				codewordlen = ret[1];
+				//
+
+				l = buckets_ptrs_b[prevCorrelatedB].bestcode;
+				bits = encoder.io_word;
+
+				if (bits > notGRprefixmask[l]) {
+					zeroprefix = cnt_l_zeroes(bits);
+					/*
+					if (bits > 0x007FFFFF) {
+						zeroprefix = lzeroes[bits >>> 24];
+					} else if (bits > 0x00007FFF) {
+						zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
+					} else if (bits > 0x0000007F) {
+						zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
+					} else {
+						zeroprefix = lzeroes24[(bits & 0x000000ff) ];
+					}*/
+
+					codewordlen = zeroprefix + 1 + l;
+					prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
+				} else {
+					codewordlen = notGRcwlen[l];
+					prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
+				}
+				correlate_row_b[i] = prevCorrelatedB;
+
+				pb = ((((xlatL2U[prevCorrelatedB] +
+					((pb +
+						result[i_4++]) >>> 1)) & bpc_mask)));
+
+				eatbits(codewordlen, encoder);
+				///////////////////// END INLINING
+
+				/**
+				pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
+				pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
+				pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
+				**/
+
+				//this is inlined apendPixel
+				resultData[pxCnt++] =
+					(255 << 24) | // alpha
+				(pb << 16) | // blue
+				(pg << 8) | // green
+				pr; // red
+				//cnt += 4;
+				i_4++;
+			}
+			if (!rle) {
+				rgb_state.waitcnt = stopidx - end;
+				encoder.cnt = pxCnt * 4;
+				encoder.pxCnt = pxCnt;
+				return;
+			}
+		}
+
+		///END of critical part
+
+		//RLE
+		rgb_state.waitcnt = stopidx - i;
+		run_index = i;
+		run_end = decode_run(encoder);
+
+		i = run_end + i;
+		while (run_end-- > 0) {
+			//this is inlined appendPixel
+			resultData[pxCnt++] =
+				computedAlpha | // alpha
+			pb << 16 | // blue
+			pg << 8 | // green
+			pr; // red
+			//cnt += 4;
+		}
+
+
+		if (i === end) {
+			encoder.cnt = pxCnt * 4;
+			encoder.pxCnt = pxCnt;
+			return;
+		}
+
+		i_1 = i - 1;
+		prevCorrelatedR = correlate_row_r[i_1];
+		prevCorrelatedG = correlate_row_g[i_1];
+		prevCorrelatedB = correlate_row_b[i_1];
+
+		stopidx = i + rgb_state.waitcnt;
+		rle = false;
+		//END RLE
+	}
+}
+
+
+function quic_uncompress_row0(encoder, channels, bpc, type) {
+	var bpc_mask = wdi.JSQuic.BPC_MASK[type];
+	var pos = 0;
+	var width = encoder.width;
+	while ((wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) && (encoder.rgb_state.wmileft <= width)) {
+		if (encoder.rgb_state.wmileft) {
+			uncompress_row0_seg(
+				encoder,
+				pos,
+				pos + encoder.rgb_state.wmileft,
+				wdi.JSQuic.bppmask[encoder.rgb_state.wmidx],
+				bpc,
+				bpc_mask,
+				type
+			);
+			pos += encoder.rgb_state.wmileft;
+			width -= encoder.rgb_state.wmileft;
+		}
+
+		encoder.rgb_state.wmidx++;
+		wdi.JSQuic.set_wm_trigger(encoder.rgb_state);
+		encoder.rgb_state.wmileft = wdi.JSQuic.wminext;
+	}
+
+	if (width) {
+		uncompress_row0_seg(
+			encoder,
+			pos,
+			pos + width,
+			wdi.JSQuic.bppmask[encoder.rgb_state.wmidx],
+			bpc,
+			bpc_mask,
+			type
+		);
+		if (wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) {
+			encoder.rgb_state.wmileft -= width;
+		}
+	}
+}
+
+function uncompress_row0_seg(encoder, i, end, waitmask, bpc, bpc_mask, type) {
+	var channel_r = encoder.channels[0];
+	var channel_g = encoder.channels[1];
+	var channel_b = encoder.channels[2];
+
+	var correlate_row_r = channel_r.correlate_row;
+	var correlate_row_g = channel_g.correlate_row;
+	var correlate_row_b = channel_b.correlate_row;
+
+	var stopidx = 0;
+
+	var pr, pg, pb;
+
+	if (!i) {
+		pr = UNCOMPRESS_ONE_ROW0_0(channel_r);
+		pg = UNCOMPRESS_ONE_ROW0_0(channel_g);
+		pb = UNCOMPRESS_ONE_ROW0_0(channel_b);
+
+		encoder.appendPixel(pr, pg, pb);
+
+		if (encoder.rgb_state.waitcnt) {
+			--encoder.rgb_state.waitcnt;
+		} else {
+			encoder.rgb_state.waitcnt = (wdi.JSQuic.tabrand(encoder.rgb_state) & waitmask);
+			UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+		}
+		stopidx = ++i + encoder.rgb_state.waitcnt;
+	} else {
+		stopidx = i + encoder.rgb_state.waitcnt;
+	}
+
+	while (stopidx < end) {
+		for (; i <= stopidx; i++) {
+			pr = UNCOMPRESS_ONE_ROW0(channel_r, i, bpc_mask, encoder, correlate_row_r, pr);
+			pg = UNCOMPRESS_ONE_ROW0(channel_g, i, bpc_mask, encoder, correlate_row_g, pg);
+			pb = UNCOMPRESS_ONE_ROW0(channel_b, i, bpc_mask, encoder, correlate_row_b, pb);
+
+			encoder.appendPixel(pr, pg, pb);
+		}
+		UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
+		stopidx = i + (wdi.JSQuic.tabrand(encoder.rgb_state) & waitmask);
+	}
+
+	for (; i < end; i++) {
+		pr = UNCOMPRESS_ONE_ROW0(channel_r, i, bpc_mask, encoder, correlate_row_r, pr);
+		pg = UNCOMPRESS_ONE_ROW0(channel_g, i, bpc_mask, encoder, correlate_row_g, pg);
+		pb = UNCOMPRESS_ONE_ROW0(channel_b, i, bpc_mask, encoder, correlate_row_b, pb);
+		encoder.appendPixel(pr, pg, pb);
+	}
+	encoder.rgb_state.waitcnt = stopidx - end;
+}
+
+function UNCOMPRESS_ONE_0(channel, encoder, bpc_mask, offset) {
+	var ret, codewordlen;
+	channel.oldFirst = channel.correlate_row[0];
+	ret = golomb_decoding(find_bucket(channel,
+		channel.correlate_row[0]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	channel.correlate_row[0] = ret[0];
+	codewordlen = ret[1];
+	var residuum = wdi.xlatL2U[channel.correlate_row[0]];
+	var prev = encoder.result[offset + channel.num_channel]; //PIXEL_B
+	var resultpixel = ((residuum + prev) & bpc_mask);
+	encoder.eatbits(codewordlen, encoder);
+	return resultpixel;
+}
+
+function UNCOMPRESS_ONE(channel, i, i_1, i_4, bpc_mask, encoder, correlate_row, offset, result, num_channel, xlatL2U, buckets_ptrs, prev_pixel) {
+	var ret, codewordlen;
+	ret = golomb_decoding(buckets_ptrs[correlate_row[i_1]].bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+
+	var data = ret[0];
+	codewordlen = ret[1];
+	correlate_row[i] = data;
+
+	var ret = ((((xlatL2U[data] +
+		((prev_pixel +
+			result[offset + (i_4) + num_channel]) >>> 1)) & bpc_mask)));
+
+	encoder.eatbits(codewordlen, encoder);
+	return ret;
+}
+
+
+function UNCOMPRESS_ONE_ROW0_0(channel) {
+	var ret, codewordlen;
+	var encoder = channel.encoder;
+	ret = golomb_decoding(find_bucket(channel, 0).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	channel.correlate_row[0] = ret[0]
+	codewordlen = ret[1];
+	var ret = wdi.xlatL2U[channel.correlate_row[0]];
+	encoder.eatbits(codewordlen, encoder);
+	return ret;
+}
+
+function UNCOMPRESS_ONE_ROW0(channel, i, bpc_mask, encoder, correlate_row, prev_pixel) {
+	var ret, codewordlen;
+	ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
+	correlate_row[i] = ret[0];
+	codewordlen = ret[1];
+	var ret = CORELATE_0(encoder, channel, i, bpc_mask, correlate_row, prev_pixel);
+	encoder.eatbits(codewordlen, encoder);
+	return ret;
+}
+
+function CORELATE_0(encoder, channel, curr, bpc_mask, correlate_row, prev_pixel) {
+	return ((wdi.xlatL2U[correlate_row[curr]] + prev_pixel) & bpc_mask);
+}
+
+function PIXEL_A(encoder) {
+	return encoder.result[encoder.cnt - 4];
+}
+
+function PIXEL_B(channel, encoder, pos, offset) {
+	return encoder.result[offset + (pos * 4) + channel.num_channel];
+}
+
+///////////////////////////////////////////////////////////////////
+//LZ
+
+var lzDecompress = {
+	LZ_IMAGE_TYPE_INVALID: 0,
+	LZ_IMAGE_TYPE_PLT1_LE: 1,
+	LZ_IMAGE_TYPE_PLT1_BE: 2,
+	LZ_IMAGE_TYPE_PLT4_LE: 3,
+	LZ_IMAGE_TYPE_PLT4_BE: 4,
+	LZ_IMAGE_TYPE_PLT8: 5,
+	LZ_IMAGE_TYPE_RGB16: 6,
+	LZ_IMAGE_TYPE_RGB24: 7,
+	LZ_IMAGE_TYPE_RGB32: 8,
+	LZ_IMAGE_TYPE_RGBA: 9,
+	LZ_IMAGE_TYPE_XXXA: 10,
+	LZPALETTE_FLAG_PAL_CACHE_ME: 1,
+	LZPALETTE_FLAG_PAL_FROM_CACHE: 2,
+	LZPALETTE_FLAG_TOP_DOWN: 4,
+	PLT_PIXELS_PER_BYTE: [0, 8, 8, 2, 2, 1],
+	PLT1_MASK: [1, 2, 4, 8, 16, 32, 64, 128],
+
+	lz_rgb32_decompress_rgb: function lz_rgb32_decompress_rgb(arr) {
+		//TODO: global alpha and uncouple code
+		var encoder = 1;
+		var op = 0;
+
+		var in_buf = new Uint8Array(arr);
+
+		var opaque = in_buf[encoder+1];
+		var type = in_buf[encoder+2];
+
+		encoder+=3; //padding
+
+		var low = in_buf[encoder + 1] * 256 + in_buf[encoder]; // 256 = Math.pow(16, 2)
+		encoder += 2;
+		var high = in_buf[encoder + 1] * 256 + in_buf[encoder]; // 256 = Math.pow(16, 2)
+		encoder += 2;
+
+		var len = high * 65536 + low; // 65536 = Math.pow(16,4)
+
+		var buf = new ArrayBuffer(len);
+		var data = new Uint32Array(buf);
+
+		var out_buf_len = len / 4;
+
+		var code, ref, ofs, b;
+		var op_4, aux;
+
+		var pre_255_24 = 255 << 24;
+		var pre_31_8_plus255 = (31 << 8) + 255;
+
+		var ctrl = in_buf[encoder++];
+		var offsetView;
+
+		do {
+			len = ctrl >> 5; //get the first 3 bits from ctrl
+
+			if (len !== 0) { //>=32
+				ref = op;
+				ofs = (ctrl & 31) << 8; //get the last 5 bits from ctrl
+
+				if (len === 7) {
+					do {
+						code = in_buf[encoder++];
+						len += code;
+					} while (code === 255);
+				}
+
+				ofs += in_buf[encoder++];
+
+				if (ofs === pre_31_8_plus255) { //check if all the bits in ofs are 1, then get two more bytes
+					ofs += (in_buf[encoder] << 8) + in_buf[encoder+1];
+					encoder += 2;
+				}
+
+				if (ofs === 0) {
+					aux = data[--ref];
+					var INSERT_AUX_CODE_HERE;
+					if(len !== 0) {
+						do {
+							data[op++] = aux;
+						} while (--len !== 0);
+					}
+
+				} else {
+					ref -= ofs + 1;
+					//if the copy from array to array is bigger than 100 (tested using benchmark) its cheaper to
+					//create a view and copy with set. If the copy is less than 100, then its cheaper
+					//to just iterate it.
+					if(len > 100 && ref+len < op) {
+						offsetView = new Uint32Array(buf, ref*4, len);
+						data.set(offsetView,op);
+						op += len;
+						ref += len;
+					} else {
+						if(len > 9) {
+							do {
+								data[op] = data[ref];
+								data[op+1] = data[ref+1];
+								data[op+2] = data[ref+2];
+								data[op+3] = data[ref+3];
+								data[op+4] = data[ref+4];
+								data[op+5] = data[ref+5];
+								data[op+6] = data[ref+6];
+								data[op+7] = data[ref+7];
+								data[op+8] = data[ref+8];
+								data[op+9] = data[ref+9];
+								op+=10;
+								len -= 10;
+								ref += 10;
+							} while(len > 9);
+						}
+						if(len !== 0) {
+							do {
+								data[op++] = data[ref++];
+							} while (--len !== 0);
+						}
+					}
+
+				}
+			} else {
+				var INSERT_COLOR_CODE_HERE;
+				do  {
+					data[op++] = pre_255_24 | // alpha
+					in_buf[encoder] << 16 | // blue
+					in_buf[encoder+1] << 8 | // green
+					in_buf[encoder+2]; // red
+					encoder+=3;
+				} while (ctrl-- !== 0);
+			}
+			ctrl = in_buf[encoder++]
+		}  while (op < out_buf_len);
+
+
+
+
+
+		if (type === this.LZ_IMAGE_TYPE_RGBA && !opaque) {
+			var buf8 = new Uint8Array(buf);
+
+			op = 0;
+			ctrl = null;
+			encoder--;
+			for (ctrl = in_buf[encoder++]; op < out_buf_len; ctrl = in_buf[encoder++]) {
+				ref = op;
+				len = ctrl >> 5;
+				ofs = ((ctrl & 31) << 8);
+				op_4 = op * 4;
+
+				if (ctrl >= 32) {
+
+					code;
+					len--;
+
+					if (len === 7 - 1) {
+						do {
+							code = in_buf[encoder++];
+							len += code;
+						} while (code === 255);
+					}
+					code = in_buf[encoder++];
+					ofs += code;
+
+
+					if (code === 255) {
+						if ((ofs - code) === (31 << 8)) {
+							ofs = in_buf[encoder++] << 8;
+							ofs += in_buf[encoder++];
+							ofs += 8191;
+						}
+					}
+					len += 3;
+
+					ofs += 1;
+
+					ref -= ofs;
+					if (ref === (op - 1)) { //plt4/1 what?
+						b = ref;
+
+						for (; len; --len) {
+							op_4 = op * 4;
+							//COPY_PIXEL
+							buf8[(op_4) + 3] = buf8[(b * 4) + 3];
+
+							op++;
+						}
+					} else {
+
+						for (; len; --len) {
+							//COPY_REF_PIXEL
+							op_4 = op * 4;
+							buf8[(op_4) + 3] = buf8[(ref * 4) + 3];
+
+							op++;
+							ref++;
+						}
+					}
+				} else {
+					//COPY_COMP_PIXEL
+					ctrl++;
+					buf8[(op_4) + 3] = in_buf[encoder++];
+					op++;
+
+
+					for (--ctrl; ctrl; ctrl--) {
+						//COPY_COMP_PIXEL
+						op_4 = op * 4; // faster?
+						buf8[(op_4) + 3] = in_buf[encoder++];
+						op++;
+					}
+				}
+			}
+		}
+		return buf;
+	}
+};
+
+var fnCode = lzDecompress.lz_rgb32_decompress_rgb.toString();
+fnCode = generate_aux_optimizers(fnCode);
+fnCode = generate_color_optimizers(fnCode);
+eval(fnCode);
+lzDecompress.lz_rgb32_decompress_rgb = lz_rgb32_decompress_rgb;
+
+function generate_aux_optimizers(code) {
+	//var auxFnCode = generate_aux_optimizer(100);
+	var auxFnCode = generate_aux_optimizer(10);
+	code = code.replace('var INSERT_AUX_CODE_HERE', auxFnCode);
+	return code;
+}
+
+function generate_aux_optimizer(num) {
+	var auxFnCode = "if(len > "+(num-1)+") {\ndo{\n";
+	for(var i=0;i<num;i++) {
+		auxFnCode += "data[op+"+i+"] = aux;\n";
+	}
+	auxFnCode += "op+="+num+";len -= "+num+";\n} while(len > "+(num-1)+") }\n";
+	return auxFnCode;
+}
+
+function generate_color_optimizers(code) {
+	var auxFnCode = generate_color_optimizer(100);
+	auxFnCode += generate_color_optimizer(10);
+	code = code.replace('var INSERT_COLOR_CODE_HERE', auxFnCode);
+	return code;
+}
+
+function generate_color_optimizer(num) {
+	var auxFnCode = "if(ctrl > "+(num-1)+") {\ndo{\n";
+	for(var i=0;i<num;i++) {
+		auxFnCode += "data[op++] = pre_255_24 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];\n";
+		auxFnCode += "encoder+=3;\n";
+	}
+	auxFnCode += "encoder+="+(num*3)+";op+="+num+";ctrl -= "+num+";\n} while(len > "+(num-1)+") }\n";
+	return auxFnCode;
+}
+
+if (wdi.LZSS) {
+	wdi.LZSS.lz_rgb32_decompress_rgb = lzDecompress.lz_rgb32_decompress_rgb
+} else {
+// if (!wdi.LZSS) {
+	wdi.LZSS = lzDecompress;
+}