1 // Generated Code - DO NOT EDIT !!
2 // generated by 'emugen'
3 
4 
5 #include <string.h>
6 #include "gles1_opcodes.h"
7 
8 #include "gles1_dec.h"
9 
10 
11 #include "ProtocolUtils.h"
12 
13 #include "ChecksumCalculatorThreadInfo.h"
14 
15 #include "host-common/logging.h"
16 
17 #include <stdio.h>
18 
19 namespace gfxstream {
20 
21 typedef unsigned int tsize_t; // Target "size_t", which is 32-bit for now. It may or may not be the same as host's size_t when emugen is compiled.
22 
23 #ifdef CHECK_GL_ERRORS
24 #  define SET_LASTCALL(name)  sprintf(lastCall, #name)
25 #else
26 #  define SET_LASTCALL(name)
27 #endif
decode(void * buf,size_t len,IOStream * stream,ChecksumCalculator * checksumCalc)28 size_t gles1_decoder_context_t::decode(void *buf, size_t len, IOStream *stream, ChecksumCalculator* checksumCalc) {
29 	if (len < 8) return 0;
30 #ifdef CHECK_GL_ERRORS
31 	char lastCall[256] = {0};
32 #endif
33 	unsigned char *ptr = (unsigned char *)buf;
34 	const unsigned char* const end = (const unsigned char*)buf + len;
35     const size_t checksumSize = checksumCalc->checksumByteSize();
36     const bool useChecksum = checksumSize > 0;
37 	while (end - ptr >= 8) {
38 		uint32_t opcode = *(uint32_t *)ptr;
39 		uint32_t packetLen = *(uint32_t *)(ptr + 4);
40 		if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
41 		switch(opcode) {
42 		case OP_glAlphaFunc: {
43 			android::base::beginTrace("glAlphaFunc decode");
44 			GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
45 			GLclampf var_ref = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
46 			if (useChecksum) {
47 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
48 					"gles1_decoder_context_t::decode, OP_glAlphaFunc: GL checksumCalculator failure\n");
49 			}
50 			#ifdef CHECK_GL_ERRORS
51 			GLint err = this->glGetError();
52 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFunc\n", err);
53 			#endif
54 			DECODER_DEBUG_LOG("gles1(%p): glAlphaFunc(func:0x%08x ref:%f )", stream, var_func, var_ref);
55 			this->glAlphaFunc(var_func, var_ref);
56 			SET_LASTCALL("glAlphaFunc");
57 			android::base::endTrace();
58 			break;
59 		}
60 		case OP_glClearColor: {
61 			android::base::beginTrace("glClearColor decode");
62 			GLclampf var_red = Unpack<GLclampf,uint32_t>(ptr + 8);
63 			GLclampf var_green = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
64 			GLclampf var_blue = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4);
65 			GLclampf var_alpha = Unpack<GLclampf,uint32_t>(ptr + 8 + 4 + 4 + 4);
66 			if (useChecksum) {
67 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
68 					"gles1_decoder_context_t::decode, OP_glClearColor: GL checksumCalculator failure\n");
69 			}
70 			#ifdef CHECK_GL_ERRORS
71 			GLint err = this->glGetError();
72 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColor\n", err);
73 			#endif
74 			DECODER_DEBUG_LOG("gles1(%p): glClearColor(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
75 			this->glClearColor(var_red, var_green, var_blue, var_alpha);
76 			SET_LASTCALL("glClearColor");
77 			android::base::endTrace();
78 			break;
79 		}
80 		case OP_glClearDepthf: {
81 			android::base::beginTrace("glClearDepthf decode");
82 			GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
83 			if (useChecksum) {
84 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
85 					"gles1_decoder_context_t::decode, OP_glClearDepthf: GL checksumCalculator failure\n");
86 			}
87 			#ifdef CHECK_GL_ERRORS
88 			GLint err = this->glGetError();
89 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthf\n", err);
90 			#endif
91 			DECODER_DEBUG_LOG("gles1(%p): glClearDepthf(depth:%f )", stream, var_depth);
92 			this->glClearDepthf(var_depth);
93 			SET_LASTCALL("glClearDepthf");
94 			android::base::endTrace();
95 			break;
96 		}
97 		case OP_glClipPlanef: {
98 			android::base::beginTrace("glClipPlanef decode");
99 			GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
100 			uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
101 			InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
102 			if (useChecksum) {
103 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
104 					"gles1_decoder_context_t::decode, OP_glClipPlanef: GL checksumCalculator failure\n");
105 			}
106 			#ifdef CHECK_GL_ERRORS
107 			GLint err = this->glGetError();
108 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanef\n", err);
109 			#endif
110 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanef(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
111 			this->glClipPlanef(var_plane, (const GLfloat*)(inptr_equation.get()));
112 			SET_LASTCALL("glClipPlanef");
113 			android::base::endTrace();
114 			break;
115 		}
116 		case OP_glColor4f: {
117 			android::base::beginTrace("glColor4f decode");
118 			GLfloat var_red = Unpack<GLfloat,uint32_t>(ptr + 8);
119 			GLfloat var_green = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
120 			GLfloat var_blue = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
121 			GLfloat var_alpha = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
122 			if (useChecksum) {
123 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
124 					"gles1_decoder_context_t::decode, OP_glColor4f: GL checksumCalculator failure\n");
125 			}
126 			#ifdef CHECK_GL_ERRORS
127 			GLint err = this->glGetError();
128 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4f\n", err);
129 			#endif
130 			DECODER_DEBUG_LOG("gles1(%p): glColor4f(red:%f green:%f blue:%f alpha:%f )", stream, var_red, var_green, var_blue, var_alpha);
131 			this->glColor4f(var_red, var_green, var_blue, var_alpha);
132 			SET_LASTCALL("glColor4f");
133 			android::base::endTrace();
134 			break;
135 		}
136 		case OP_glDepthRangef: {
137 			android::base::beginTrace("glDepthRangef decode");
138 			GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
139 			GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
140 			if (useChecksum) {
141 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
142 					"gles1_decoder_context_t::decode, OP_glDepthRangef: GL checksumCalculator failure\n");
143 			}
144 			#ifdef CHECK_GL_ERRORS
145 			GLint err = this->glGetError();
146 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangef\n", err);
147 			#endif
148 			DECODER_DEBUG_LOG("gles1(%p): glDepthRangef(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
149 			this->glDepthRangef(var_zNear, var_zFar);
150 			SET_LASTCALL("glDepthRangef");
151 			android::base::endTrace();
152 			break;
153 		}
154 		case OP_glFogf: {
155 			android::base::beginTrace("glFogf decode");
156 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
157 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
158 			if (useChecksum) {
159 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
160 					"gles1_decoder_context_t::decode, OP_glFogf: GL checksumCalculator failure\n");
161 			}
162 			#ifdef CHECK_GL_ERRORS
163 			GLint err = this->glGetError();
164 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogf\n", err);
165 			#endif
166 			DECODER_DEBUG_LOG("gles1(%p): glFogf(pname:0x%08x param:%f )", stream, var_pname, var_param);
167 			this->glFogf(var_pname, var_param);
168 			SET_LASTCALL("glFogf");
169 			android::base::endTrace();
170 			break;
171 		}
172 		case OP_glFogfv: {
173 			android::base::beginTrace("glFogfv decode");
174 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
175 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
176 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
177 			if (useChecksum) {
178 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
179 					"gles1_decoder_context_t::decode, OP_glFogfv: GL checksumCalculator failure\n");
180 			}
181 			#ifdef CHECK_GL_ERRORS
182 			GLint err = this->glGetError();
183 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogfv\n", err);
184 			#endif
185 			DECODER_DEBUG_LOG("gles1(%p): glFogfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
186 			this->glFogfv(var_pname, (const GLfloat*)(inptr_params.get()));
187 			SET_LASTCALL("glFogfv");
188 			android::base::endTrace();
189 			break;
190 		}
191 		case OP_glFrustumf: {
192 			android::base::beginTrace("glFrustumf decode");
193 			GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
194 			GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
195 			GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
196 			GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
197 			GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
198 			GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
199 			if (useChecksum) {
200 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
201 					"gles1_decoder_context_t::decode, OP_glFrustumf: GL checksumCalculator failure\n");
202 			}
203 			#ifdef CHECK_GL_ERRORS
204 			GLint err = this->glGetError();
205 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumf\n", err);
206 			#endif
207 			DECODER_DEBUG_LOG("gles1(%p): glFrustumf(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
208 			this->glFrustumf(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
209 			SET_LASTCALL("glFrustumf");
210 			android::base::endTrace();
211 			break;
212 		}
213 		case OP_glGetClipPlanef: {
214 			android::base::beginTrace("glGetClipPlanef decode");
215 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
216 			uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
217 			if (useChecksum) {
218 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
219 					"gles1_decoder_context_t::decode, OP_glGetClipPlanef: GL checksumCalculator failure\n");
220 			}
221 			size_t totalTmpSize = size_eqn;
222 			totalTmpSize += checksumSize;
223 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
224 			OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
225 			#ifdef CHECK_GL_ERRORS
226 			GLint err = this->glGetError();
227 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanef\n", err);
228 			#endif
229 			DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanef(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
230 			this->glGetClipPlanef(var_pname, (GLfloat*)(outptr_eqn.get()));
231 			outptr_eqn.flush();
232 			if (useChecksum) {
233 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
234 			}
235 			stream->flush();
236 			SET_LASTCALL("glGetClipPlanef");
237 			android::base::endTrace();
238 			break;
239 		}
240 		case OP_glGetFloatv: {
241 			android::base::beginTrace("glGetFloatv decode");
242 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
243 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
244 			if (useChecksum) {
245 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
246 					"gles1_decoder_context_t::decode, OP_glGetFloatv: GL checksumCalculator failure\n");
247 			}
248 			size_t totalTmpSize = size_params;
249 			totalTmpSize += checksumSize;
250 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
251 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
252 			#ifdef CHECK_GL_ERRORS
253 			GLint err = this->glGetError();
254 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFloatv\n", err);
255 			#endif
256 			DECODER_DEBUG_LOG("gles1(%p): glGetFloatv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_params.get()), size_params);
257 			this->glGetFloatv(var_pname, (GLfloat*)(outptr_params.get()));
258 			outptr_params.flush();
259 			if (useChecksum) {
260 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
261 			}
262 			stream->flush();
263 			SET_LASTCALL("glGetFloatv");
264 			android::base::endTrace();
265 			break;
266 		}
267 		case OP_glGetLightfv: {
268 			android::base::beginTrace("glGetLightfv decode");
269 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
270 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
271 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
272 			if (useChecksum) {
273 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
274 					"gles1_decoder_context_t::decode, OP_glGetLightfv: GL checksumCalculator failure\n");
275 			}
276 			size_t totalTmpSize = size_params;
277 			totalTmpSize += checksumSize;
278 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
279 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
280 			#ifdef CHECK_GL_ERRORS
281 			GLint err = this->glGetError();
282 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightfv\n", err);
283 			#endif
284 			DECODER_DEBUG_LOG("gles1(%p): glGetLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfloat*)(outptr_params.get()), size_params);
285 			this->glGetLightfv(var_light, var_pname, (GLfloat*)(outptr_params.get()));
286 			outptr_params.flush();
287 			if (useChecksum) {
288 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
289 			}
290 			stream->flush();
291 			SET_LASTCALL("glGetLightfv");
292 			android::base::endTrace();
293 			break;
294 		}
295 		case OP_glGetMaterialfv: {
296 			android::base::beginTrace("glGetMaterialfv decode");
297 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
298 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
299 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
300 			if (useChecksum) {
301 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
302 					"gles1_decoder_context_t::decode, OP_glGetMaterialfv: GL checksumCalculator failure\n");
303 			}
304 			size_t totalTmpSize = size_params;
305 			totalTmpSize += checksumSize;
306 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
307 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
308 			#ifdef CHECK_GL_ERRORS
309 			GLint err = this->glGetError();
310 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialfv\n", err);
311 			#endif
312 			DECODER_DEBUG_LOG("gles1(%p): glGetMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfloat*)(outptr_params.get()), size_params);
313 			this->glGetMaterialfv(var_face, var_pname, (GLfloat*)(outptr_params.get()));
314 			outptr_params.flush();
315 			if (useChecksum) {
316 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
317 			}
318 			stream->flush();
319 			SET_LASTCALL("glGetMaterialfv");
320 			android::base::endTrace();
321 			break;
322 		}
323 		case OP_glGetTexEnvfv: {
324 			android::base::beginTrace("glGetTexEnvfv decode");
325 			GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
326 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
327 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
328 			if (useChecksum) {
329 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
330 					"gles1_decoder_context_t::decode, OP_glGetTexEnvfv: GL checksumCalculator failure\n");
331 			}
332 			size_t totalTmpSize = size_params;
333 			totalTmpSize += checksumSize;
334 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
335 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
336 			#ifdef CHECK_GL_ERRORS
337 			GLint err = this->glGetError();
338 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvfv\n", err);
339 			#endif
340 			DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvfv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfloat*)(outptr_params.get()), size_params);
341 			this->glGetTexEnvfv(var_env, var_pname, (GLfloat*)(outptr_params.get()));
342 			outptr_params.flush();
343 			if (useChecksum) {
344 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
345 			}
346 			stream->flush();
347 			SET_LASTCALL("glGetTexEnvfv");
348 			android::base::endTrace();
349 			break;
350 		}
351 		case OP_glGetTexParameterfv: {
352 			android::base::beginTrace("glGetTexParameterfv decode");
353 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
354 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
355 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
356 			if (useChecksum) {
357 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
358 					"gles1_decoder_context_t::decode, OP_glGetTexParameterfv: GL checksumCalculator failure\n");
359 			}
360 			size_t totalTmpSize = size_params;
361 			totalTmpSize += checksumSize;
362 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
363 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
364 			#ifdef CHECK_GL_ERRORS
365 			GLint err = this->glGetError();
366 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterfv\n", err);
367 			#endif
368 			DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfloat*)(outptr_params.get()), size_params);
369 			this->glGetTexParameterfv(var_target, var_pname, (GLfloat*)(outptr_params.get()));
370 			outptr_params.flush();
371 			if (useChecksum) {
372 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
373 			}
374 			stream->flush();
375 			SET_LASTCALL("glGetTexParameterfv");
376 			android::base::endTrace();
377 			break;
378 		}
379 		case OP_glLightModelf: {
380 			android::base::beginTrace("glLightModelf decode");
381 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
382 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
383 			if (useChecksum) {
384 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
385 					"gles1_decoder_context_t::decode, OP_glLightModelf: GL checksumCalculator failure\n");
386 			}
387 			#ifdef CHECK_GL_ERRORS
388 			GLint err = this->glGetError();
389 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelf\n", err);
390 			#endif
391 			DECODER_DEBUG_LOG("gles1(%p): glLightModelf(pname:0x%08x param:%f )", stream, var_pname, var_param);
392 			this->glLightModelf(var_pname, var_param);
393 			SET_LASTCALL("glLightModelf");
394 			android::base::endTrace();
395 			break;
396 		}
397 		case OP_glLightModelfv: {
398 			android::base::beginTrace("glLightModelfv decode");
399 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
400 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
401 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
402 			if (useChecksum) {
403 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
404 					"gles1_decoder_context_t::decode, OP_glLightModelfv: GL checksumCalculator failure\n");
405 			}
406 			#ifdef CHECK_GL_ERRORS
407 			GLint err = this->glGetError();
408 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelfv\n", err);
409 			#endif
410 			DECODER_DEBUG_LOG("gles1(%p): glLightModelfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
411 			this->glLightModelfv(var_pname, (const GLfloat*)(inptr_params.get()));
412 			SET_LASTCALL("glLightModelfv");
413 			android::base::endTrace();
414 			break;
415 		}
416 		case OP_glLightf: {
417 			android::base::beginTrace("glLightf decode");
418 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
419 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
420 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
421 			if (useChecksum) {
422 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
423 					"gles1_decoder_context_t::decode, OP_glLightf: GL checksumCalculator failure\n");
424 			}
425 			#ifdef CHECK_GL_ERRORS
426 			GLint err = this->glGetError();
427 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightf\n", err);
428 			#endif
429 			DECODER_DEBUG_LOG("gles1(%p): glLightf(light:0x%08x pname:0x%08x param:%f )", stream, var_light, var_pname, var_param);
430 			this->glLightf(var_light, var_pname, var_param);
431 			SET_LASTCALL("glLightf");
432 			android::base::endTrace();
433 			break;
434 		}
435 		case OP_glLightfv: {
436 			android::base::beginTrace("glLightfv decode");
437 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
438 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
439 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
440 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
441 			if (useChecksum) {
442 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
443 					"gles1_decoder_context_t::decode, OP_glLightfv: GL checksumCalculator failure\n");
444 			}
445 			#ifdef CHECK_GL_ERRORS
446 			GLint err = this->glGetError();
447 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightfv\n", err);
448 			#endif
449 			DECODER_DEBUG_LOG("gles1(%p): glLightfv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
450 			this->glLightfv(var_light, var_pname, (const GLfloat*)(inptr_params.get()));
451 			SET_LASTCALL("glLightfv");
452 			android::base::endTrace();
453 			break;
454 		}
455 		case OP_glLineWidth: {
456 			android::base::beginTrace("glLineWidth decode");
457 			GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8);
458 			if (useChecksum) {
459 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
460 					"gles1_decoder_context_t::decode, OP_glLineWidth: GL checksumCalculator failure\n");
461 			}
462 			#ifdef CHECK_GL_ERRORS
463 			GLint err = this->glGetError();
464 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidth\n", err);
465 			#endif
466 			DECODER_DEBUG_LOG("gles1(%p): glLineWidth(width:%f )", stream, var_width);
467 			this->glLineWidth(var_width);
468 			SET_LASTCALL("glLineWidth");
469 			android::base::endTrace();
470 			break;
471 		}
472 		case OP_glLoadMatrixf: {
473 			android::base::beginTrace("glLoadMatrixf decode");
474 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
475 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
476 			if (useChecksum) {
477 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
478 					"gles1_decoder_context_t::decode, OP_glLoadMatrixf: GL checksumCalculator failure\n");
479 			}
480 			#ifdef CHECK_GL_ERRORS
481 			GLint err = this->glGetError();
482 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixf\n", err);
483 			#endif
484 			DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
485 			this->glLoadMatrixf((const GLfloat*)(inptr_m.get()));
486 			SET_LASTCALL("glLoadMatrixf");
487 			android::base::endTrace();
488 			break;
489 		}
490 		case OP_glMaterialf: {
491 			android::base::beginTrace("glMaterialf decode");
492 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
493 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
494 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
495 			if (useChecksum) {
496 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
497 					"gles1_decoder_context_t::decode, OP_glMaterialf: GL checksumCalculator failure\n");
498 			}
499 			#ifdef CHECK_GL_ERRORS
500 			GLint err = this->glGetError();
501 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialf\n", err);
502 			#endif
503 			DECODER_DEBUG_LOG("gles1(%p): glMaterialf(face:0x%08x pname:0x%08x param:%f )", stream, var_face, var_pname, var_param);
504 			this->glMaterialf(var_face, var_pname, var_param);
505 			SET_LASTCALL("glMaterialf");
506 			android::base::endTrace();
507 			break;
508 		}
509 		case OP_glMaterialfv: {
510 			android::base::beginTrace("glMaterialfv decode");
511 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
512 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
513 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
514 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
515 			if (useChecksum) {
516 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
517 					"gles1_decoder_context_t::decode, OP_glMaterialfv: GL checksumCalculator failure\n");
518 			}
519 			#ifdef CHECK_GL_ERRORS
520 			GLint err = this->glGetError();
521 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialfv\n", err);
522 			#endif
523 			DECODER_DEBUG_LOG("gles1(%p): glMaterialfv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
524 			this->glMaterialfv(var_face, var_pname, (const GLfloat*)(inptr_params.get()));
525 			SET_LASTCALL("glMaterialfv");
526 			android::base::endTrace();
527 			break;
528 		}
529 		case OP_glMultMatrixf: {
530 			android::base::beginTrace("glMultMatrixf decode");
531 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
532 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
533 			if (useChecksum) {
534 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
535 					"gles1_decoder_context_t::decode, OP_glMultMatrixf: GL checksumCalculator failure\n");
536 			}
537 			#ifdef CHECK_GL_ERRORS
538 			GLint err = this->glGetError();
539 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixf\n", err);
540 			#endif
541 			DECODER_DEBUG_LOG("gles1(%p): glMultMatrixf(m:%p(%u) )", stream, (const GLfloat*)(inptr_m.get()), size_m);
542 			this->glMultMatrixf((const GLfloat*)(inptr_m.get()));
543 			SET_LASTCALL("glMultMatrixf");
544 			android::base::endTrace();
545 			break;
546 		}
547 		case OP_glMultiTexCoord4f: {
548 			android::base::beginTrace("glMultiTexCoord4f decode");
549 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
550 			GLfloat var_s = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
551 			GLfloat var_t = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
552 			GLfloat var_r = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
553 			GLfloat var_q = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
554 			if (useChecksum) {
555 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
556 					"gles1_decoder_context_t::decode, OP_glMultiTexCoord4f: GL checksumCalculator failure\n");
557 			}
558 			#ifdef CHECK_GL_ERRORS
559 			GLint err = this->glGetError();
560 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4f\n", err);
561 			#endif
562 			DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4f(target:0x%08x s:%f t:%f r:%f q:%f )", stream, var_target, var_s, var_t, var_r, var_q);
563 			this->glMultiTexCoord4f(var_target, var_s, var_t, var_r, var_q);
564 			SET_LASTCALL("glMultiTexCoord4f");
565 			android::base::endTrace();
566 			break;
567 		}
568 		case OP_glNormal3f: {
569 			android::base::beginTrace("glNormal3f decode");
570 			GLfloat var_nx = Unpack<GLfloat,uint32_t>(ptr + 8);
571 			GLfloat var_ny = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
572 			GLfloat var_nz = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
573 			if (useChecksum) {
574 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
575 					"gles1_decoder_context_t::decode, OP_glNormal3f: GL checksumCalculator failure\n");
576 			}
577 			#ifdef CHECK_GL_ERRORS
578 			GLint err = this->glGetError();
579 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3f\n", err);
580 			#endif
581 			DECODER_DEBUG_LOG("gles1(%p): glNormal3f(nx:%f ny:%f nz:%f )", stream, var_nx, var_ny, var_nz);
582 			this->glNormal3f(var_nx, var_ny, var_nz);
583 			SET_LASTCALL("glNormal3f");
584 			android::base::endTrace();
585 			break;
586 		}
587 		case OP_glOrthof: {
588 			android::base::beginTrace("glOrthof decode");
589 			GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
590 			GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
591 			GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
592 			GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
593 			GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
594 			GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
595 			if (useChecksum) {
596 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
597 					"gles1_decoder_context_t::decode, OP_glOrthof: GL checksumCalculator failure\n");
598 			}
599 			#ifdef CHECK_GL_ERRORS
600 			GLint err = this->glGetError();
601 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthof\n", err);
602 			#endif
603 			DECODER_DEBUG_LOG("gles1(%p): glOrthof(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
604 			this->glOrthof(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
605 			SET_LASTCALL("glOrthof");
606 			android::base::endTrace();
607 			break;
608 		}
609 		case OP_glPointParameterf: {
610 			android::base::beginTrace("glPointParameterf decode");
611 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
612 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
613 			if (useChecksum) {
614 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
615 					"gles1_decoder_context_t::decode, OP_glPointParameterf: GL checksumCalculator failure\n");
616 			}
617 			#ifdef CHECK_GL_ERRORS
618 			GLint err = this->glGetError();
619 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterf\n", err);
620 			#endif
621 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterf(pname:0x%08x param:%f )", stream, var_pname, var_param);
622 			this->glPointParameterf(var_pname, var_param);
623 			SET_LASTCALL("glPointParameterf");
624 			android::base::endTrace();
625 			break;
626 		}
627 		case OP_glPointParameterfv: {
628 			android::base::beginTrace("glPointParameterfv decode");
629 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
630 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
631 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
632 			if (useChecksum) {
633 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
634 					"gles1_decoder_context_t::decode, OP_glPointParameterfv: GL checksumCalculator failure\n");
635 			}
636 			#ifdef CHECK_GL_ERRORS
637 			GLint err = this->glGetError();
638 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterfv\n", err);
639 			#endif
640 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterfv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
641 			this->glPointParameterfv(var_pname, (const GLfloat*)(inptr_params.get()));
642 			SET_LASTCALL("glPointParameterfv");
643 			android::base::endTrace();
644 			break;
645 		}
646 		case OP_glPointSize: {
647 			android::base::beginTrace("glPointSize decode");
648 			GLfloat var_size = Unpack<GLfloat,uint32_t>(ptr + 8);
649 			if (useChecksum) {
650 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
651 					"gles1_decoder_context_t::decode, OP_glPointSize: GL checksumCalculator failure\n");
652 			}
653 			#ifdef CHECK_GL_ERRORS
654 			GLint err = this->glGetError();
655 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSize\n", err);
656 			#endif
657 			DECODER_DEBUG_LOG("gles1(%p): glPointSize(size:%f )", stream, var_size);
658 			this->glPointSize(var_size);
659 			SET_LASTCALL("glPointSize");
660 			android::base::endTrace();
661 			break;
662 		}
663 		case OP_glPolygonOffset: {
664 			android::base::beginTrace("glPolygonOffset decode");
665 			GLfloat var_factor = Unpack<GLfloat,uint32_t>(ptr + 8);
666 			GLfloat var_units = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
667 			if (useChecksum) {
668 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
669 					"gles1_decoder_context_t::decode, OP_glPolygonOffset: GL checksumCalculator failure\n");
670 			}
671 			#ifdef CHECK_GL_ERRORS
672 			GLint err = this->glGetError();
673 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffset\n", err);
674 			#endif
675 			DECODER_DEBUG_LOG("gles1(%p): glPolygonOffset(factor:%f units:%f )", stream, var_factor, var_units);
676 			this->glPolygonOffset(var_factor, var_units);
677 			SET_LASTCALL("glPolygonOffset");
678 			android::base::endTrace();
679 			break;
680 		}
681 		case OP_glRotatef: {
682 			android::base::beginTrace("glRotatef decode");
683 			GLfloat var_angle = Unpack<GLfloat,uint32_t>(ptr + 8);
684 			GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
685 			GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
686 			GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
687 			if (useChecksum) {
688 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
689 					"gles1_decoder_context_t::decode, OP_glRotatef: GL checksumCalculator failure\n");
690 			}
691 			#ifdef CHECK_GL_ERRORS
692 			GLint err = this->glGetError();
693 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatef\n", err);
694 			#endif
695 			DECODER_DEBUG_LOG("gles1(%p): glRotatef(angle:%f x:%f y:%f z:%f )", stream, var_angle, var_x, var_y, var_z);
696 			this->glRotatef(var_angle, var_x, var_y, var_z);
697 			SET_LASTCALL("glRotatef");
698 			android::base::endTrace();
699 			break;
700 		}
701 		case OP_glScalef: {
702 			android::base::beginTrace("glScalef decode");
703 			GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
704 			GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
705 			GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
706 			if (useChecksum) {
707 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
708 					"gles1_decoder_context_t::decode, OP_glScalef: GL checksumCalculator failure\n");
709 			}
710 			#ifdef CHECK_GL_ERRORS
711 			GLint err = this->glGetError();
712 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalef\n", err);
713 			#endif
714 			DECODER_DEBUG_LOG("gles1(%p): glScalef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
715 			this->glScalef(var_x, var_y, var_z);
716 			SET_LASTCALL("glScalef");
717 			android::base::endTrace();
718 			break;
719 		}
720 		case OP_glTexEnvf: {
721 			android::base::beginTrace("glTexEnvf decode");
722 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
723 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
724 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
725 			if (useChecksum) {
726 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
727 					"gles1_decoder_context_t::decode, OP_glTexEnvf: GL checksumCalculator failure\n");
728 			}
729 			#ifdef CHECK_GL_ERRORS
730 			GLint err = this->glGetError();
731 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvf\n", err);
732 			#endif
733 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
734 			this->glTexEnvf(var_target, var_pname, var_param);
735 			SET_LASTCALL("glTexEnvf");
736 			android::base::endTrace();
737 			break;
738 		}
739 		case OP_glTexEnvfv: {
740 			android::base::beginTrace("glTexEnvfv decode");
741 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
742 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
743 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
744 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
745 			if (useChecksum) {
746 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
747 					"gles1_decoder_context_t::decode, OP_glTexEnvfv: GL checksumCalculator failure\n");
748 			}
749 			#ifdef CHECK_GL_ERRORS
750 			GLint err = this->glGetError();
751 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvfv\n", err);
752 			#endif
753 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
754 			this->glTexEnvfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
755 			SET_LASTCALL("glTexEnvfv");
756 			android::base::endTrace();
757 			break;
758 		}
759 		case OP_glTexParameterf: {
760 			android::base::beginTrace("glTexParameterf decode");
761 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
762 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
763 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
764 			if (useChecksum) {
765 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
766 					"gles1_decoder_context_t::decode, OP_glTexParameterf: GL checksumCalculator failure\n");
767 			}
768 			#ifdef CHECK_GL_ERRORS
769 			GLint err = this->glGetError();
770 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterf\n", err);
771 			#endif
772 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterf(target:0x%08x pname:0x%08x param:%f )", stream, var_target, var_pname, var_param);
773 			this->glTexParameterf(var_target, var_pname, var_param);
774 			SET_LASTCALL("glTexParameterf");
775 			android::base::endTrace();
776 			break;
777 		}
778 		case OP_glTexParameterfv: {
779 			android::base::beginTrace("glTexParameterfv decode");
780 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
781 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
782 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
783 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
784 			if (useChecksum) {
785 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
786 					"gles1_decoder_context_t::decode, OP_glTexParameterfv: GL checksumCalculator failure\n");
787 			}
788 			#ifdef CHECK_GL_ERRORS
789 			GLint err = this->glGetError();
790 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterfv\n", err);
791 			#endif
792 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterfv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
793 			this->glTexParameterfv(var_target, var_pname, (const GLfloat*)(inptr_params.get()));
794 			SET_LASTCALL("glTexParameterfv");
795 			android::base::endTrace();
796 			break;
797 		}
798 		case OP_glTranslatef: {
799 			android::base::beginTrace("glTranslatef decode");
800 			GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
801 			GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
802 			GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
803 			if (useChecksum) {
804 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
805 					"gles1_decoder_context_t::decode, OP_glTranslatef: GL checksumCalculator failure\n");
806 			}
807 			#ifdef CHECK_GL_ERRORS
808 			GLint err = this->glGetError();
809 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatef\n", err);
810 			#endif
811 			DECODER_DEBUG_LOG("gles1(%p): glTranslatef(x:%f y:%f z:%f )", stream, var_x, var_y, var_z);
812 			this->glTranslatef(var_x, var_y, var_z);
813 			SET_LASTCALL("glTranslatef");
814 			android::base::endTrace();
815 			break;
816 		}
817 		case OP_glActiveTexture: {
818 			android::base::beginTrace("glActiveTexture decode");
819 			GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
820 			if (useChecksum) {
821 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
822 					"gles1_decoder_context_t::decode, OP_glActiveTexture: GL checksumCalculator failure\n");
823 			}
824 			#ifdef CHECK_GL_ERRORS
825 			GLint err = this->glGetError();
826 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glActiveTexture\n", err);
827 			#endif
828 			DECODER_DEBUG_LOG("gles1(%p): glActiveTexture(texture:0x%08x )", stream, var_texture);
829 			this->glActiveTexture(var_texture);
830 			SET_LASTCALL("glActiveTexture");
831 			android::base::endTrace();
832 			break;
833 		}
834 		case OP_glAlphaFuncx: {
835 			android::base::beginTrace("glAlphaFuncx decode");
836 			GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
837 			GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
838 			if (useChecksum) {
839 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
840 					"gles1_decoder_context_t::decode, OP_glAlphaFuncx: GL checksumCalculator failure\n");
841 			}
842 			#ifdef CHECK_GL_ERRORS
843 			GLint err = this->glGetError();
844 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncx\n", err);
845 			#endif
846 			DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncx(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
847 			this->glAlphaFuncx(var_func, var_ref);
848 			SET_LASTCALL("glAlphaFuncx");
849 			android::base::endTrace();
850 			break;
851 		}
852 		case OP_glBindBuffer: {
853 			android::base::beginTrace("glBindBuffer decode");
854 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
855 			GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
856 			if (useChecksum) {
857 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
858 					"gles1_decoder_context_t::decode, OP_glBindBuffer: GL checksumCalculator failure\n");
859 			}
860 			#ifdef CHECK_GL_ERRORS
861 			GLint err = this->glGetError();
862 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindBuffer\n", err);
863 			#endif
864 			DECODER_DEBUG_LOG("gles1(%p): glBindBuffer(target:0x%08x buffer:%u )", stream, var_target, var_buffer);
865 			this->glBindBuffer(var_target, var_buffer);
866 			SET_LASTCALL("glBindBuffer");
867 			android::base::endTrace();
868 			break;
869 		}
870 		case OP_glBindTexture: {
871 			android::base::beginTrace("glBindTexture decode");
872 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
873 			GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
874 			if (useChecksum) {
875 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
876 					"gles1_decoder_context_t::decode, OP_glBindTexture: GL checksumCalculator failure\n");
877 			}
878 			#ifdef CHECK_GL_ERRORS
879 			GLint err = this->glGetError();
880 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindTexture\n", err);
881 			#endif
882 			DECODER_DEBUG_LOG("gles1(%p): glBindTexture(target:0x%08x texture:%u )", stream, var_target, var_texture);
883 			this->glBindTexture(var_target, var_texture);
884 			SET_LASTCALL("glBindTexture");
885 			android::base::endTrace();
886 			break;
887 		}
888 		case OP_glBlendFunc: {
889 			android::base::beginTrace("glBlendFunc decode");
890 			GLenum var_sfactor = Unpack<GLenum,uint32_t>(ptr + 8);
891 			GLenum var_dfactor = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
892 			if (useChecksum) {
893 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
894 					"gles1_decoder_context_t::decode, OP_glBlendFunc: GL checksumCalculator failure\n");
895 			}
896 			#ifdef CHECK_GL_ERRORS
897 			GLint err = this->glGetError();
898 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFunc\n", err);
899 			#endif
900 			DECODER_DEBUG_LOG("gles1(%p): glBlendFunc(sfactor:0x%08x dfactor:0x%08x )", stream, var_sfactor, var_dfactor);
901 			this->glBlendFunc(var_sfactor, var_dfactor);
902 			SET_LASTCALL("glBlendFunc");
903 			android::base::endTrace();
904 			break;
905 		}
906 		case OP_glBufferData: {
907 			android::base::beginTrace("glBufferData decode");
908 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
909 			GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4);
910 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
911 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
912 			GLenum var_usage = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
913 			if (useChecksum) {
914 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
915 					"gles1_decoder_context_t::decode, OP_glBufferData: GL checksumCalculator failure\n");
916 			}
917 			#ifdef CHECK_GL_ERRORS
918 			GLint err = this->glGetError();
919 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferData\n", err);
920 			#endif
921 			DECODER_DEBUG_LOG("gles1(%p): glBufferData(target:0x%08x size:0x%08lx data:%p(%u) usage:0x%08x )", stream, var_target, var_size, (const GLvoid*)(inptr_data.get()), size_data, var_usage);
922 			this->glBufferData(var_target, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()), var_usage);
923 			SET_LASTCALL("glBufferData");
924 			android::base::endTrace();
925 			break;
926 		}
927 		case OP_glBufferSubData: {
928 			android::base::beginTrace("glBufferSubData decode");
929 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
930 			GLintptr var_offset = Unpack<GLintptr,uint32_t>(ptr + 8 + 4);
931 			GLsizeiptr var_size = Unpack<GLsizeiptr,uint32_t>(ptr + 8 + 4 + 4);
932 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
933 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
934 			if (useChecksum) {
935 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + size_data, checksumSize,
936 					"gles1_decoder_context_t::decode, OP_glBufferSubData: GL checksumCalculator failure\n");
937 			}
938 			#ifdef CHECK_GL_ERRORS
939 			GLint err = this->glGetError();
940 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBufferSubData\n", err);
941 			#endif
942 			DECODER_DEBUG_LOG("gles1(%p): glBufferSubData(target:0x%08x offset:0x%08lx size:0x%08lx data:%p(%u) )", stream, var_target, var_offset, var_size, (const GLvoid*)(inptr_data.get()), size_data);
943 			this->glBufferSubData(var_target, var_offset, var_size, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
944 			SET_LASTCALL("glBufferSubData");
945 			android::base::endTrace();
946 			break;
947 		}
948 		case OP_glClear: {
949 			android::base::beginTrace("glClear decode");
950 			GLbitfield var_mask = Unpack<GLbitfield,uint32_t>(ptr + 8);
951 			if (useChecksum) {
952 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
953 					"gles1_decoder_context_t::decode, OP_glClear: GL checksumCalculator failure\n");
954 			}
955 			#ifdef CHECK_GL_ERRORS
956 			GLint err = this->glGetError();
957 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClear\n", err);
958 			#endif
959 			DECODER_DEBUG_LOG("gles1(%p): glClear(mask:0x%08x )", stream, var_mask);
960 			this->glClear(var_mask);
961 			SET_LASTCALL("glClear");
962 			android::base::endTrace();
963 			break;
964 		}
965 		case OP_glClearColorx: {
966 			android::base::beginTrace("glClearColorx decode");
967 			GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
968 			GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
969 			GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
970 			GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
971 			if (useChecksum) {
972 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
973 					"gles1_decoder_context_t::decode, OP_glClearColorx: GL checksumCalculator failure\n");
974 			}
975 			#ifdef CHECK_GL_ERRORS
976 			GLint err = this->glGetError();
977 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorx\n", err);
978 			#endif
979 			DECODER_DEBUG_LOG("gles1(%p): glClearColorx(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
980 			this->glClearColorx(var_red, var_green, var_blue, var_alpha);
981 			SET_LASTCALL("glClearColorx");
982 			android::base::endTrace();
983 			break;
984 		}
985 		case OP_glClearDepthx: {
986 			android::base::beginTrace("glClearDepthx decode");
987 			GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
988 			if (useChecksum) {
989 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
990 					"gles1_decoder_context_t::decode, OP_glClearDepthx: GL checksumCalculator failure\n");
991 			}
992 			#ifdef CHECK_GL_ERRORS
993 			GLint err = this->glGetError();
994 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthx\n", err);
995 			#endif
996 			DECODER_DEBUG_LOG("gles1(%p): glClearDepthx(depth:0x%08x )", stream, var_depth);
997 			this->glClearDepthx(var_depth);
998 			SET_LASTCALL("glClearDepthx");
999 			android::base::endTrace();
1000 			break;
1001 		}
1002 		case OP_glClearStencil: {
1003 			android::base::beginTrace("glClearStencil decode");
1004 			GLint var_s = Unpack<GLint,uint32_t>(ptr + 8);
1005 			if (useChecksum) {
1006 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1007 					"gles1_decoder_context_t::decode, OP_glClearStencil: GL checksumCalculator failure\n");
1008 			}
1009 			#ifdef CHECK_GL_ERRORS
1010 			GLint err = this->glGetError();
1011 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearStencil\n", err);
1012 			#endif
1013 			DECODER_DEBUG_LOG("gles1(%p): glClearStencil(s:%d )", stream, var_s);
1014 			this->glClearStencil(var_s);
1015 			SET_LASTCALL("glClearStencil");
1016 			android::base::endTrace();
1017 			break;
1018 		}
1019 		case OP_glClientActiveTexture: {
1020 			android::base::beginTrace("glClientActiveTexture decode");
1021 			GLenum var_texture = Unpack<GLenum,uint32_t>(ptr + 8);
1022 			if (useChecksum) {
1023 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1024 					"gles1_decoder_context_t::decode, OP_glClientActiveTexture: GL checksumCalculator failure\n");
1025 			}
1026 			#ifdef CHECK_GL_ERRORS
1027 			GLint err = this->glGetError();
1028 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClientActiveTexture\n", err);
1029 			#endif
1030 			DECODER_DEBUG_LOG("gles1(%p): glClientActiveTexture(texture:0x%08x )", stream, var_texture);
1031 			this->glClientActiveTexture(var_texture);
1032 			SET_LASTCALL("glClientActiveTexture");
1033 			android::base::endTrace();
1034 			break;
1035 		}
1036 		case OP_glColor4ub: {
1037 			android::base::beginTrace("glColor4ub decode");
1038 			GLubyte var_red = Unpack<GLubyte,uint8_t>(ptr + 8);
1039 			GLubyte var_green = Unpack<GLubyte,uint8_t>(ptr + 8 + 1);
1040 			GLubyte var_blue = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1);
1041 			GLubyte var_alpha = Unpack<GLubyte,uint8_t>(ptr + 8 + 1 + 1 + 1);
1042 			if (useChecksum) {
1043 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
1044 					"gles1_decoder_context_t::decode, OP_glColor4ub: GL checksumCalculator failure\n");
1045 			}
1046 			#ifdef CHECK_GL_ERRORS
1047 			GLint err = this->glGetError();
1048 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4ub\n", err);
1049 			#endif
1050 			DECODER_DEBUG_LOG("gles1(%p): glColor4ub(red:0x%02x green:0x%02x blue:0x%02x alpha:0x%02x )", stream, var_red, var_green, var_blue, var_alpha);
1051 			this->glColor4ub(var_red, var_green, var_blue, var_alpha);
1052 			SET_LASTCALL("glColor4ub");
1053 			android::base::endTrace();
1054 			break;
1055 		}
1056 		case OP_glColor4x: {
1057 			android::base::beginTrace("glColor4x decode");
1058 			GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
1059 			GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1060 			GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
1061 			GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
1062 			if (useChecksum) {
1063 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
1064 					"gles1_decoder_context_t::decode, OP_glColor4x: GL checksumCalculator failure\n");
1065 			}
1066 			#ifdef CHECK_GL_ERRORS
1067 			GLint err = this->glGetError();
1068 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4x\n", err);
1069 			#endif
1070 			DECODER_DEBUG_LOG("gles1(%p): glColor4x(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
1071 			this->glColor4x(var_red, var_green, var_blue, var_alpha);
1072 			SET_LASTCALL("glColor4x");
1073 			android::base::endTrace();
1074 			break;
1075 		}
1076 		case OP_glColorMask: {
1077 			android::base::beginTrace("glColorMask decode");
1078 			GLboolean var_red = Unpack<GLboolean,uint8_t>(ptr + 8);
1079 			GLboolean var_green = Unpack<GLboolean,uint8_t>(ptr + 8 + 1);
1080 			GLboolean var_blue = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1);
1081 			GLboolean var_alpha = Unpack<GLboolean,uint8_t>(ptr + 8 + 1 + 1 + 1);
1082 			if (useChecksum) {
1083 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1 + 1 + 1 + 1, ptr + 8 + 1 + 1 + 1 + 1, checksumSize,
1084 					"gles1_decoder_context_t::decode, OP_glColorMask: GL checksumCalculator failure\n");
1085 			}
1086 			#ifdef CHECK_GL_ERRORS
1087 			GLint err = this->glGetError();
1088 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorMask\n", err);
1089 			#endif
1090 			DECODER_DEBUG_LOG("gles1(%p): glColorMask(red:%d green:%d blue:%d alpha:%d )", stream, var_red, var_green, var_blue, var_alpha);
1091 			this->glColorMask(var_red, var_green, var_blue, var_alpha);
1092 			SET_LASTCALL("glColorMask");
1093 			android::base::endTrace();
1094 			break;
1095 		}
1096 		case OP_glColorPointer: {
1097 			android::base::beginTrace("glColorPointer decode");
1098 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
1099 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1100 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
1101 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
1102 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
1103 			if (useChecksum) {
1104 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
1105 					"gles1_decoder_context_t::decode, OP_glColorPointer: GL checksumCalculator failure\n");
1106 			}
1107 			#ifdef CHECK_GL_ERRORS
1108 			GLint err = this->glGetError();
1109 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointer\n", err);
1110 			#endif
1111 			DECODER_DEBUG_LOG("gles1(%p): glColorPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
1112 			this->glColorPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
1113 			SET_LASTCALL("glColorPointer");
1114 			android::base::endTrace();
1115 			break;
1116 		}
1117 		case OP_glCompressedTexImage2D: {
1118 			android::base::beginTrace("glCompressedTexImage2D decode");
1119 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1120 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1121 			GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1122 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
1123 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1124 			GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1125 			GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1126 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1127 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
1128 			if (useChecksum) {
1129 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
1130 					"gles1_decoder_context_t::decode, OP_glCompressedTexImage2D: GL checksumCalculator failure\n");
1131 			}
1132 			#ifdef CHECK_GL_ERRORS
1133 			GLint err = this->glGetError();
1134 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexImage2D\n", err);
1135 			#endif
1136 			DECODER_DEBUG_LOG("gles1(%p): glCompressedTexImage2D(target:0x%08x level:%d internalformat:0x%08x width:%d height:%d border:%d imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
1137 			this->glCompressedTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
1138 			SET_LASTCALL("glCompressedTexImage2D");
1139 			android::base::endTrace();
1140 			break;
1141 		}
1142 		case OP_glCompressedTexSubImage2D: {
1143 			android::base::beginTrace("glCompressedTexSubImage2D decode");
1144 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1145 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1146 			GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
1147 			GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1148 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1149 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1150 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1151 			GLsizei var_imageSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1152 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1153 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_data);
1154 			if (useChecksum) {
1155 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_data, checksumSize,
1156 					"gles1_decoder_context_t::decode, OP_glCompressedTexSubImage2D: GL checksumCalculator failure\n");
1157 			}
1158 			#ifdef CHECK_GL_ERRORS
1159 			GLint err = this->glGetError();
1160 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCompressedTexSubImage2D\n", err);
1161 			#endif
1162 			DECODER_DEBUG_LOG("gles1(%p): glCompressedTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x imageSize:%d data:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, (const GLvoid*)(inptr_data.get()), size_data);
1163 			this->glCompressedTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_imageSize, size_data == 0 ? nullptr : (const GLvoid*)(inptr_data.get()));
1164 			SET_LASTCALL("glCompressedTexSubImage2D");
1165 			android::base::endTrace();
1166 			break;
1167 		}
1168 		case OP_glCopyTexImage2D: {
1169 			android::base::beginTrace("glCopyTexImage2D decode");
1170 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1171 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1172 			GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1173 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1174 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1175 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1176 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1177 			GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1178 			if (useChecksum) {
1179 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1180 					"gles1_decoder_context_t::decode, OP_glCopyTexImage2D: GL checksumCalculator failure\n");
1181 			}
1182 			#ifdef CHECK_GL_ERRORS
1183 			GLint err = this->glGetError();
1184 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexImage2D\n", err);
1185 			#endif
1186 			DECODER_DEBUG_LOG("gles1(%p): glCopyTexImage2D(target:0x%08x level:%d internalformat:0x%08x x:%d y:%d width:%d height:%d border:%d )", stream, var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
1187 			this->glCopyTexImage2D(var_target, var_level, var_internalformat, var_x, var_y, var_width, var_height, var_border);
1188 			SET_LASTCALL("glCopyTexImage2D");
1189 			android::base::endTrace();
1190 			break;
1191 		}
1192 		case OP_glCopyTexSubImage2D: {
1193 			android::base::beginTrace("glCopyTexSubImage2D decode");
1194 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1195 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1196 			GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
1197 			GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
1198 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1199 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1200 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
1201 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
1202 			if (useChecksum) {
1203 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1204 					"gles1_decoder_context_t::decode, OP_glCopyTexSubImage2D: GL checksumCalculator failure\n");
1205 			}
1206 			#ifdef CHECK_GL_ERRORS
1207 			GLint err = this->glGetError();
1208 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCopyTexSubImage2D\n", err);
1209 			#endif
1210 			DECODER_DEBUG_LOG("gles1(%p): glCopyTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d x:%d y:%d width:%d height:%d )", stream, var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
1211 			this->glCopyTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_x, var_y, var_width, var_height);
1212 			SET_LASTCALL("glCopyTexSubImage2D");
1213 			android::base::endTrace();
1214 			break;
1215 		}
1216 		case OP_glCullFace: {
1217 			android::base::beginTrace("glCullFace decode");
1218 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1219 			if (useChecksum) {
1220 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1221 					"gles1_decoder_context_t::decode, OP_glCullFace: GL checksumCalculator failure\n");
1222 			}
1223 			#ifdef CHECK_GL_ERRORS
1224 			GLint err = this->glGetError();
1225 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCullFace\n", err);
1226 			#endif
1227 			DECODER_DEBUG_LOG("gles1(%p): glCullFace(mode:0x%08x )", stream, var_mode);
1228 			this->glCullFace(var_mode);
1229 			SET_LASTCALL("glCullFace");
1230 			android::base::endTrace();
1231 			break;
1232 		}
1233 		case OP_glDeleteBuffers: {
1234 			android::base::beginTrace("glDeleteBuffers decode");
1235 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1236 			uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1237 			InputBuffer inptr_buffers(ptr + 8 + 4 + 4, size_buffers);
1238 			if (useChecksum) {
1239 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_buffers, ptr + 8 + 4 + 4 + size_buffers, checksumSize,
1240 					"gles1_decoder_context_t::decode, OP_glDeleteBuffers: GL checksumCalculator failure\n");
1241 			}
1242 			#ifdef CHECK_GL_ERRORS
1243 			GLint err = this->glGetError();
1244 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteBuffers\n", err);
1245 			#endif
1246 			DECODER_DEBUG_LOG("gles1(%p): glDeleteBuffers(n:%d buffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_buffers.get()), size_buffers);
1247 			this->glDeleteBuffers_dec(this, var_n, (const GLuint*)(inptr_buffers.get()));
1248 			SET_LASTCALL("glDeleteBuffers");
1249 			android::base::endTrace();
1250 			break;
1251 		}
1252 		case OP_glDeleteTextures: {
1253 			android::base::beginTrace("glDeleteTextures decode");
1254 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1255 			uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1256 			InputBuffer inptr_textures(ptr + 8 + 4 + 4, size_textures);
1257 			if (useChecksum) {
1258 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_textures, ptr + 8 + 4 + 4 + size_textures, checksumSize,
1259 					"gles1_decoder_context_t::decode, OP_glDeleteTextures: GL checksumCalculator failure\n");
1260 			}
1261 			#ifdef CHECK_GL_ERRORS
1262 			GLint err = this->glGetError();
1263 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteTextures\n", err);
1264 			#endif
1265 			DECODER_DEBUG_LOG("gles1(%p): glDeleteTextures(n:%d textures:%p(%u) )", stream, var_n, (const GLuint*)(inptr_textures.get()), size_textures);
1266 			this->glDeleteTextures_dec(this, var_n, (const GLuint*)(inptr_textures.get()));
1267 			SET_LASTCALL("glDeleteTextures");
1268 			android::base::endTrace();
1269 			break;
1270 		}
1271 		case OP_glDepthFunc: {
1272 			android::base::beginTrace("glDepthFunc decode");
1273 			GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
1274 			if (useChecksum) {
1275 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1276 					"gles1_decoder_context_t::decode, OP_glDepthFunc: GL checksumCalculator failure\n");
1277 			}
1278 			#ifdef CHECK_GL_ERRORS
1279 			GLint err = this->glGetError();
1280 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthFunc\n", err);
1281 			#endif
1282 			DECODER_DEBUG_LOG("gles1(%p): glDepthFunc(func:0x%08x )", stream, var_func);
1283 			this->glDepthFunc(var_func);
1284 			SET_LASTCALL("glDepthFunc");
1285 			android::base::endTrace();
1286 			break;
1287 		}
1288 		case OP_glDepthMask: {
1289 			android::base::beginTrace("glDepthMask decode");
1290 			GLboolean var_flag = Unpack<GLboolean,uint8_t>(ptr + 8);
1291 			if (useChecksum) {
1292 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 1, ptr + 8 + 1, checksumSize,
1293 					"gles1_decoder_context_t::decode, OP_glDepthMask: GL checksumCalculator failure\n");
1294 			}
1295 			#ifdef CHECK_GL_ERRORS
1296 			GLint err = this->glGetError();
1297 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthMask\n", err);
1298 			#endif
1299 			DECODER_DEBUG_LOG("gles1(%p): glDepthMask(flag:%d )", stream, var_flag);
1300 			this->glDepthMask(var_flag);
1301 			SET_LASTCALL("glDepthMask");
1302 			android::base::endTrace();
1303 			break;
1304 		}
1305 		case OP_glDepthRangex: {
1306 			android::base::beginTrace("glDepthRangex decode");
1307 			GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
1308 			GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
1309 			if (useChecksum) {
1310 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1311 					"gles1_decoder_context_t::decode, OP_glDepthRangex: GL checksumCalculator failure\n");
1312 			}
1313 			#ifdef CHECK_GL_ERRORS
1314 			GLint err = this->glGetError();
1315 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangex\n", err);
1316 			#endif
1317 			DECODER_DEBUG_LOG("gles1(%p): glDepthRangex(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
1318 			this->glDepthRangex(var_zNear, var_zFar);
1319 			SET_LASTCALL("glDepthRangex");
1320 			android::base::endTrace();
1321 			break;
1322 		}
1323 		case OP_glDisable: {
1324 			android::base::beginTrace("glDisable decode");
1325 			GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1326 			if (useChecksum) {
1327 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1328 					"gles1_decoder_context_t::decode, OP_glDisable: GL checksumCalculator failure\n");
1329 			}
1330 			#ifdef CHECK_GL_ERRORS
1331 			GLint err = this->glGetError();
1332 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisable\n", err);
1333 			#endif
1334 			DECODER_DEBUG_LOG("gles1(%p): glDisable(cap:0x%08x )", stream, var_cap);
1335 			this->glDisable(var_cap);
1336 			SET_LASTCALL("glDisable");
1337 			android::base::endTrace();
1338 			break;
1339 		}
1340 		case OP_glDisableClientState: {
1341 			android::base::beginTrace("glDisableClientState decode");
1342 			GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
1343 			if (useChecksum) {
1344 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1345 					"gles1_decoder_context_t::decode, OP_glDisableClientState: GL checksumCalculator failure\n");
1346 			}
1347 			#ifdef CHECK_GL_ERRORS
1348 			GLint err = this->glGetError();
1349 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableClientState\n", err);
1350 			#endif
1351 			DECODER_DEBUG_LOG("gles1(%p): glDisableClientState(array:0x%08x )", stream, var_array);
1352 			this->glDisableClientState(var_array);
1353 			SET_LASTCALL("glDisableClientState");
1354 			android::base::endTrace();
1355 			break;
1356 		}
1357 		case OP_glDrawArrays: {
1358 			android::base::beginTrace("glDrawArrays decode");
1359 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1360 			GLint var_first = Unpack<GLint,uint32_t>(ptr + 8 + 4);
1361 			GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
1362 			if (useChecksum) {
1363 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1364 					"gles1_decoder_context_t::decode, OP_glDrawArrays: GL checksumCalculator failure\n");
1365 			}
1366 			#ifdef CHECK_GL_ERRORS
1367 			GLint err = this->glGetError();
1368 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawArrays\n", err);
1369 			#endif
1370 			DECODER_DEBUG_LOG("gles1(%p): glDrawArrays(mode:0x%08x first:%d count:%d )", stream, var_mode, var_first, var_count);
1371 			this->glDrawArrays(var_mode, var_first, var_count);
1372 			SET_LASTCALL("glDrawArrays");
1373 			android::base::endTrace();
1374 			break;
1375 		}
1376 		case OP_glDrawElements: {
1377 			android::base::beginTrace("glDrawElements decode");
1378 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1379 			GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
1380 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
1381 			uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
1382 			InputBuffer inptr_indices(ptr + 8 + 4 + 4 + 4 + 4, size_indices);
1383 			if (useChecksum) {
1384 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_indices, ptr + 8 + 4 + 4 + 4 + 4 + size_indices, checksumSize,
1385 					"gles1_decoder_context_t::decode, OP_glDrawElements: GL checksumCalculator failure\n");
1386 			}
1387 			#ifdef CHECK_GL_ERRORS
1388 			GLint err = this->glGetError();
1389 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElements\n", err);
1390 			#endif
1391 			DECODER_DEBUG_LOG("gles1(%p): glDrawElements(mode:0x%08x count:%d type:0x%08x indices:%p(%u) )", stream, var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()), size_indices);
1392 			this->glDrawElements(var_mode, var_count, var_type, (const GLvoid*)(inptr_indices.get()));
1393 			SET_LASTCALL("glDrawElements");
1394 			android::base::endTrace();
1395 			break;
1396 		}
1397 		case OP_glEnable: {
1398 			android::base::beginTrace("glEnable decode");
1399 			GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1400 			if (useChecksum) {
1401 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1402 					"gles1_decoder_context_t::decode, OP_glEnable: GL checksumCalculator failure\n");
1403 			}
1404 			#ifdef CHECK_GL_ERRORS
1405 			GLint err = this->glGetError();
1406 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnable\n", err);
1407 			#endif
1408 			DECODER_DEBUG_LOG("gles1(%p): glEnable(cap:0x%08x )", stream, var_cap);
1409 			this->glEnable(var_cap);
1410 			SET_LASTCALL("glEnable");
1411 			android::base::endTrace();
1412 			break;
1413 		}
1414 		case OP_glEnableClientState: {
1415 			android::base::beginTrace("glEnableClientState decode");
1416 			GLenum var_array = Unpack<GLenum,uint32_t>(ptr + 8);
1417 			if (useChecksum) {
1418 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1419 					"gles1_decoder_context_t::decode, OP_glEnableClientState: GL checksumCalculator failure\n");
1420 			}
1421 			#ifdef CHECK_GL_ERRORS
1422 			GLint err = this->glGetError();
1423 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableClientState\n", err);
1424 			#endif
1425 			DECODER_DEBUG_LOG("gles1(%p): glEnableClientState(array:0x%08x )", stream, var_array);
1426 			this->glEnableClientState(var_array);
1427 			SET_LASTCALL("glEnableClientState");
1428 			android::base::endTrace();
1429 			break;
1430 		}
1431 		case OP_glFinish: {
1432 			android::base::beginTrace("glFinish decode");
1433 			if (useChecksum) {
1434 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1435 					"gles1_decoder_context_t::decode, OP_glFinish: GL checksumCalculator failure\n");
1436 			}
1437 			#ifdef CHECK_GL_ERRORS
1438 			GLint err = this->glGetError();
1439 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinish\n", err);
1440 			#endif
1441 			DECODER_DEBUG_LOG("gles1(%p): glFinish()", stream);
1442 			this->glFinish();
1443 			SET_LASTCALL("glFinish");
1444 			android::base::endTrace();
1445 			break;
1446 		}
1447 		case OP_glFlush: {
1448 			android::base::beginTrace("glFlush decode");
1449 			if (useChecksum) {
1450 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1451 					"gles1_decoder_context_t::decode, OP_glFlush: GL checksumCalculator failure\n");
1452 			}
1453 			#ifdef CHECK_GL_ERRORS
1454 			GLint err = this->glGetError();
1455 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFlush\n", err);
1456 			#endif
1457 			DECODER_DEBUG_LOG("gles1(%p): glFlush()", stream);
1458 			this->glFlush();
1459 			SET_LASTCALL("glFlush");
1460 			android::base::endTrace();
1461 			break;
1462 		}
1463 		case OP_glFogx: {
1464 			android::base::beginTrace("glFogx decode");
1465 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1466 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1467 			if (useChecksum) {
1468 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1469 					"gles1_decoder_context_t::decode, OP_glFogx: GL checksumCalculator failure\n");
1470 			}
1471 			#ifdef CHECK_GL_ERRORS
1472 			GLint err = this->glGetError();
1473 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogx\n", err);
1474 			#endif
1475 			DECODER_DEBUG_LOG("gles1(%p): glFogx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
1476 			this->glFogx(var_pname, var_param);
1477 			SET_LASTCALL("glFogx");
1478 			android::base::endTrace();
1479 			break;
1480 		}
1481 		case OP_glFogxv: {
1482 			android::base::beginTrace("glFogxv decode");
1483 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1484 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1485 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
1486 			if (useChecksum) {
1487 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
1488 					"gles1_decoder_context_t::decode, OP_glFogxv: GL checksumCalculator failure\n");
1489 			}
1490 			#ifdef CHECK_GL_ERRORS
1491 			GLint err = this->glGetError();
1492 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxv\n", err);
1493 			#endif
1494 			DECODER_DEBUG_LOG("gles1(%p): glFogxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
1495 			this->glFogxv(var_pname, (const GLfixed*)(inptr_params.get()));
1496 			SET_LASTCALL("glFogxv");
1497 			android::base::endTrace();
1498 			break;
1499 		}
1500 		case OP_glFrontFace: {
1501 			android::base::beginTrace("glFrontFace decode");
1502 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
1503 			if (useChecksum) {
1504 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1505 					"gles1_decoder_context_t::decode, OP_glFrontFace: GL checksumCalculator failure\n");
1506 			}
1507 			#ifdef CHECK_GL_ERRORS
1508 			GLint err = this->glGetError();
1509 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrontFace\n", err);
1510 			#endif
1511 			DECODER_DEBUG_LOG("gles1(%p): glFrontFace(mode:0x%08x )", stream, var_mode);
1512 			this->glFrontFace(var_mode);
1513 			SET_LASTCALL("glFrontFace");
1514 			android::base::endTrace();
1515 			break;
1516 		}
1517 		case OP_glFrustumx: {
1518 			android::base::beginTrace("glFrustumx decode");
1519 			GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
1520 			GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
1521 			GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
1522 			GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
1523 			GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
1524 			GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
1525 			if (useChecksum) {
1526 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
1527 					"gles1_decoder_context_t::decode, OP_glFrustumx: GL checksumCalculator failure\n");
1528 			}
1529 			#ifdef CHECK_GL_ERRORS
1530 			GLint err = this->glGetError();
1531 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumx\n", err);
1532 			#endif
1533 			DECODER_DEBUG_LOG("gles1(%p): glFrustumx(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
1534 			this->glFrustumx(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
1535 			SET_LASTCALL("glFrustumx");
1536 			android::base::endTrace();
1537 			break;
1538 		}
1539 		case OP_glGetBooleanv: {
1540 			android::base::beginTrace("glGetBooleanv decode");
1541 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1542 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1543 			if (useChecksum) {
1544 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1545 					"gles1_decoder_context_t::decode, OP_glGetBooleanv: GL checksumCalculator failure\n");
1546 			}
1547 			size_t totalTmpSize = size_params;
1548 			totalTmpSize += checksumSize;
1549 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1550 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1551 			#ifdef CHECK_GL_ERRORS
1552 			GLint err = this->glGetError();
1553 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBooleanv\n", err);
1554 			#endif
1555 			DECODER_DEBUG_LOG("gles1(%p): glGetBooleanv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLboolean*)(outptr_params.get()), size_params);
1556 			this->glGetBooleanv(var_pname, (GLboolean*)(outptr_params.get()));
1557 			outptr_params.flush();
1558 			if (useChecksum) {
1559 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1560 			}
1561 			stream->flush();
1562 			SET_LASTCALL("glGetBooleanv");
1563 			android::base::endTrace();
1564 			break;
1565 		}
1566 		case OP_glGetBufferParameteriv: {
1567 			android::base::beginTrace("glGetBufferParameteriv decode");
1568 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1569 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1570 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1571 			if (useChecksum) {
1572 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1573 					"gles1_decoder_context_t::decode, OP_glGetBufferParameteriv: GL checksumCalculator failure\n");
1574 			}
1575 			size_t totalTmpSize = size_params;
1576 			totalTmpSize += checksumSize;
1577 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1578 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1579 			#ifdef CHECK_GL_ERRORS
1580 			GLint err = this->glGetError();
1581 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferParameteriv\n", err);
1582 			#endif
1583 			DECODER_DEBUG_LOG("gles1(%p): glGetBufferParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
1584 			this->glGetBufferParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
1585 			outptr_params.flush();
1586 			if (useChecksum) {
1587 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1588 			}
1589 			stream->flush();
1590 			SET_LASTCALL("glGetBufferParameteriv");
1591 			android::base::endTrace();
1592 			break;
1593 		}
1594 		case OP_glClipPlanex: {
1595 			android::base::beginTrace("glClipPlanex decode");
1596 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1597 			uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1598 			InputBuffer inptr_eqn(ptr + 8 + 4 + 4, size_eqn);
1599 			if (useChecksum) {
1600 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_eqn, ptr + 8 + 4 + 4 + size_eqn, checksumSize,
1601 					"gles1_decoder_context_t::decode, OP_glClipPlanex: GL checksumCalculator failure\n");
1602 			}
1603 			#ifdef CHECK_GL_ERRORS
1604 			GLint err = this->glGetError();
1605 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanex\n", err);
1606 			#endif
1607 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_eqn.get()), size_eqn);
1608 			this->glClipPlanex(var_pname, (const GLfixed*)(inptr_eqn.get()));
1609 			SET_LASTCALL("glClipPlanex");
1610 			android::base::endTrace();
1611 			break;
1612 		}
1613 		case OP_glGenBuffers: {
1614 			android::base::beginTrace("glGenBuffers decode");
1615 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1616 			uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1617 			if (useChecksum) {
1618 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1619 					"gles1_decoder_context_t::decode, OP_glGenBuffers: GL checksumCalculator failure\n");
1620 			}
1621 			size_t totalTmpSize = size_buffers;
1622 			totalTmpSize += checksumSize;
1623 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1624 			OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
1625 			#ifdef CHECK_GL_ERRORS
1626 			GLint err = this->glGetError();
1627 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenBuffers\n", err);
1628 			#endif
1629 			DECODER_DEBUG_LOG("gles1(%p): glGenBuffers(n:%d buffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_buffers.get()), size_buffers);
1630 			this->glGenBuffers_dec(this, var_n, (GLuint*)(outptr_buffers.get()));
1631 			outptr_buffers.flush();
1632 			if (useChecksum) {
1633 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1634 			}
1635 			stream->flush();
1636 			SET_LASTCALL("glGenBuffers");
1637 			android::base::endTrace();
1638 			break;
1639 		}
1640 		case OP_glGenTextures: {
1641 			android::base::beginTrace("glGenTextures decode");
1642 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
1643 			uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1644 			if (useChecksum) {
1645 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1646 					"gles1_decoder_context_t::decode, OP_glGenTextures: GL checksumCalculator failure\n");
1647 			}
1648 			size_t totalTmpSize = size_textures;
1649 			totalTmpSize += checksumSize;
1650 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1651 			OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
1652 			#ifdef CHECK_GL_ERRORS
1653 			GLint err = this->glGetError();
1654 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenTextures\n", err);
1655 			#endif
1656 			DECODER_DEBUG_LOG("gles1(%p): glGenTextures(n:%d textures:%p(%u) )", stream, var_n, (GLuint*)(outptr_textures.get()), size_textures);
1657 			this->glGenTextures_dec(this, var_n, (GLuint*)(outptr_textures.get()));
1658 			outptr_textures.flush();
1659 			if (useChecksum) {
1660 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1661 			}
1662 			stream->flush();
1663 			SET_LASTCALL("glGenTextures");
1664 			android::base::endTrace();
1665 			break;
1666 		}
1667 		case OP_glGetError: {
1668 			android::base::beginTrace("glGetError decode");
1669 			if (useChecksum) {
1670 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
1671 					"gles1_decoder_context_t::decode, OP_glGetError: GL checksumCalculator failure\n");
1672 			}
1673 			size_t totalTmpSize = sizeof(GLenum);
1674 			totalTmpSize += checksumSize;
1675 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1676 			#ifdef CHECK_GL_ERRORS
1677 			GLint err = this->glGetError();
1678 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetError\n", err);
1679 			#endif
1680 			DECODER_DEBUG_LOG("gles1(%p): glGetError()", stream);
1681 			*(GLenum *)(&tmpBuf[0]) = 			this->glGetError();
1682 			if (useChecksum) {
1683 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1684 			}
1685 			stream->flush();
1686 			SET_LASTCALL("glGetError");
1687 			android::base::endTrace();
1688 			break;
1689 		}
1690 		case OP_glGetFixedv: {
1691 			android::base::beginTrace("glGetFixedv decode");
1692 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1693 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1694 			if (useChecksum) {
1695 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1696 					"gles1_decoder_context_t::decode, OP_glGetFixedv: GL checksumCalculator failure\n");
1697 			}
1698 			size_t totalTmpSize = size_params;
1699 			totalTmpSize += checksumSize;
1700 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1701 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1702 			#ifdef CHECK_GL_ERRORS
1703 			GLint err = this->glGetError();
1704 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedv\n", err);
1705 			#endif
1706 			DECODER_DEBUG_LOG("gles1(%p): glGetFixedv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1707 			this->glGetFixedv(var_pname, (GLfixed*)(outptr_params.get()));
1708 			outptr_params.flush();
1709 			if (useChecksum) {
1710 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1711 			}
1712 			stream->flush();
1713 			SET_LASTCALL("glGetFixedv");
1714 			android::base::endTrace();
1715 			break;
1716 		}
1717 		case OP_glGetIntegerv: {
1718 			android::base::beginTrace("glGetIntegerv decode");
1719 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1720 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1721 			if (useChecksum) {
1722 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1723 					"gles1_decoder_context_t::decode, OP_glGetIntegerv: GL checksumCalculator failure\n");
1724 			}
1725 			size_t totalTmpSize = size_params;
1726 			totalTmpSize += checksumSize;
1727 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1728 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1729 			#ifdef CHECK_GL_ERRORS
1730 			GLint err = this->glGetError();
1731 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetIntegerv\n", err);
1732 			#endif
1733 			DECODER_DEBUG_LOG("gles1(%p): glGetIntegerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLint*)(outptr_params.get()), size_params);
1734 			this->glGetIntegerv(var_pname, (GLint*)(outptr_params.get()));
1735 			outptr_params.flush();
1736 			if (useChecksum) {
1737 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1738 			}
1739 			stream->flush();
1740 			SET_LASTCALL("glGetIntegerv");
1741 			android::base::endTrace();
1742 			break;
1743 		}
1744 		case OP_glGetLightxv: {
1745 			android::base::beginTrace("glGetLightxv decode");
1746 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
1747 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1748 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1749 			if (useChecksum) {
1750 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1751 					"gles1_decoder_context_t::decode, OP_glGetLightxv: GL checksumCalculator failure\n");
1752 			}
1753 			size_t totalTmpSize = size_params;
1754 			totalTmpSize += checksumSize;
1755 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1756 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1757 			#ifdef CHECK_GL_ERRORS
1758 			GLint err = this->glGetError();
1759 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxv\n", err);
1760 			#endif
1761 			DECODER_DEBUG_LOG("gles1(%p): glGetLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1762 			this->glGetLightxv(var_light, var_pname, (GLfixed*)(outptr_params.get()));
1763 			outptr_params.flush();
1764 			if (useChecksum) {
1765 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1766 			}
1767 			stream->flush();
1768 			SET_LASTCALL("glGetLightxv");
1769 			android::base::endTrace();
1770 			break;
1771 		}
1772 		case OP_glGetMaterialxv: {
1773 			android::base::beginTrace("glGetMaterialxv decode");
1774 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
1775 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1776 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1777 			if (useChecksum) {
1778 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1779 					"gles1_decoder_context_t::decode, OP_glGetMaterialxv: GL checksumCalculator failure\n");
1780 			}
1781 			size_t totalTmpSize = size_params;
1782 			totalTmpSize += checksumSize;
1783 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1784 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1785 			#ifdef CHECK_GL_ERRORS
1786 			GLint err = this->glGetError();
1787 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxv\n", err);
1788 			#endif
1789 			DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1790 			this->glGetMaterialxv(var_face, var_pname, (GLfixed*)(outptr_params.get()));
1791 			outptr_params.flush();
1792 			if (useChecksum) {
1793 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1794 			}
1795 			stream->flush();
1796 			SET_LASTCALL("glGetMaterialxv");
1797 			android::base::endTrace();
1798 			break;
1799 		}
1800 		case OP_glGetPointerv: {
1801 			android::base::beginTrace("glGetPointerv decode");
1802 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
1803 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
1804 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
1805 			if (useChecksum) {
1806 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
1807 					"gles1_decoder_context_t::decode, OP_glGetPointerv: GL checksumCalculator failure\n");
1808 			}
1809 			#ifdef CHECK_GL_ERRORS
1810 			GLint err = this->glGetError();
1811 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetPointerv\n", err);
1812 			#endif
1813 			DECODER_DEBUG_LOG("gles1(%p): glGetPointerv(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLvoid**)(inptr_params.get()), size_params);
1814 			this->glGetPointerv(var_pname, (GLvoid**)(inptr_params.get()));
1815 			SET_LASTCALL("glGetPointerv");
1816 			android::base::endTrace();
1817 			break;
1818 		}
1819 		case OP_glGetString: {
1820 			android::base::beginTrace("glGetString decode");
1821 			GLenum var_name = Unpack<GLenum,uint32_t>(ptr + 8);
1822 			if (useChecksum) {
1823 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1824 					"gles1_decoder_context_t::decode, OP_glGetString: GL checksumCalculator failure\n");
1825 			}
1826 			#ifdef CHECK_GL_ERRORS
1827 			GLint err = this->glGetError();
1828 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetString\n", err);
1829 			#endif
1830 			DECODER_DEBUG_LOG("gles1(%p): glGetString(name:0x%08x )", stream, var_name);
1831 			this->glGetString(var_name);
1832 			SET_LASTCALL("glGetString");
1833 			android::base::endTrace();
1834 			break;
1835 		}
1836 		case OP_glGetTexEnviv: {
1837 			android::base::beginTrace("glGetTexEnviv decode");
1838 			GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
1839 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1840 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1841 			if (useChecksum) {
1842 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1843 					"gles1_decoder_context_t::decode, OP_glGetTexEnviv: GL checksumCalculator failure\n");
1844 			}
1845 			size_t totalTmpSize = size_params;
1846 			totalTmpSize += checksumSize;
1847 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1848 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1849 			#ifdef CHECK_GL_ERRORS
1850 			GLint err = this->glGetError();
1851 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnviv\n", err);
1852 			#endif
1853 			DECODER_DEBUG_LOG("gles1(%p): glGetTexEnviv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLint*)(outptr_params.get()), size_params);
1854 			this->glGetTexEnviv(var_env, var_pname, (GLint*)(outptr_params.get()));
1855 			outptr_params.flush();
1856 			if (useChecksum) {
1857 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1858 			}
1859 			stream->flush();
1860 			SET_LASTCALL("glGetTexEnviv");
1861 			android::base::endTrace();
1862 			break;
1863 		}
1864 		case OP_glGetTexEnvxv: {
1865 			android::base::beginTrace("glGetTexEnvxv decode");
1866 			GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
1867 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1868 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1869 			if (useChecksum) {
1870 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1871 					"gles1_decoder_context_t::decode, OP_glGetTexEnvxv: GL checksumCalculator failure\n");
1872 			}
1873 			size_t totalTmpSize = size_params;
1874 			totalTmpSize += checksumSize;
1875 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1876 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1877 			#ifdef CHECK_GL_ERRORS
1878 			GLint err = this->glGetError();
1879 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxv\n", err);
1880 			#endif
1881 			DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxv(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1882 			this->glGetTexEnvxv(var_env, var_pname, (GLfixed*)(outptr_params.get()));
1883 			outptr_params.flush();
1884 			if (useChecksum) {
1885 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1886 			}
1887 			stream->flush();
1888 			SET_LASTCALL("glGetTexEnvxv");
1889 			android::base::endTrace();
1890 			break;
1891 		}
1892 		case OP_glGetTexParameteriv: {
1893 			android::base::beginTrace("glGetTexParameteriv decode");
1894 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1895 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1896 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1897 			if (useChecksum) {
1898 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1899 					"gles1_decoder_context_t::decode, OP_glGetTexParameteriv: GL checksumCalculator failure\n");
1900 			}
1901 			size_t totalTmpSize = size_params;
1902 			totalTmpSize += checksumSize;
1903 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1904 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1905 			#ifdef CHECK_GL_ERRORS
1906 			GLint err = this->glGetError();
1907 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameteriv\n", err);
1908 			#endif
1909 			DECODER_DEBUG_LOG("gles1(%p): glGetTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
1910 			this->glGetTexParameteriv(var_target, var_pname, (GLint*)(outptr_params.get()));
1911 			outptr_params.flush();
1912 			if (useChecksum) {
1913 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1914 			}
1915 			stream->flush();
1916 			SET_LASTCALL("glGetTexParameteriv");
1917 			android::base::endTrace();
1918 			break;
1919 		}
1920 		case OP_glGetTexParameterxv: {
1921 			android::base::beginTrace("glGetTexParameterxv decode");
1922 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1923 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1924 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
1925 			if (useChecksum) {
1926 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
1927 					"gles1_decoder_context_t::decode, OP_glGetTexParameterxv: GL checksumCalculator failure\n");
1928 			}
1929 			size_t totalTmpSize = size_params;
1930 			totalTmpSize += checksumSize;
1931 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1932 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
1933 			#ifdef CHECK_GL_ERRORS
1934 			GLint err = this->glGetError();
1935 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxv\n", err);
1936 			#endif
1937 			DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
1938 			this->glGetTexParameterxv(var_target, var_pname, (GLfixed*)(outptr_params.get()));
1939 			outptr_params.flush();
1940 			if (useChecksum) {
1941 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1942 			}
1943 			stream->flush();
1944 			SET_LASTCALL("glGetTexParameterxv");
1945 			android::base::endTrace();
1946 			break;
1947 		}
1948 		case OP_glHint: {
1949 			android::base::beginTrace("glHint decode");
1950 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
1951 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
1952 			if (useChecksum) {
1953 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
1954 					"gles1_decoder_context_t::decode, OP_glHint: GL checksumCalculator failure\n");
1955 			}
1956 			#ifdef CHECK_GL_ERRORS
1957 			GLint err = this->glGetError();
1958 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glHint\n", err);
1959 			#endif
1960 			DECODER_DEBUG_LOG("gles1(%p): glHint(target:0x%08x mode:0x%08x )", stream, var_target, var_mode);
1961 			this->glHint(var_target, var_mode);
1962 			SET_LASTCALL("glHint");
1963 			android::base::endTrace();
1964 			break;
1965 		}
1966 		case OP_glIsBuffer: {
1967 			android::base::beginTrace("glIsBuffer decode");
1968 			GLuint var_buffer = Unpack<GLuint,uint32_t>(ptr + 8);
1969 			if (useChecksum) {
1970 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1971 					"gles1_decoder_context_t::decode, OP_glIsBuffer: GL checksumCalculator failure\n");
1972 			}
1973 			size_t totalTmpSize = sizeof(GLboolean);
1974 			totalTmpSize += checksumSize;
1975 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
1976 			#ifdef CHECK_GL_ERRORS
1977 			GLint err = this->glGetError();
1978 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsBuffer\n", err);
1979 			#endif
1980 			DECODER_DEBUG_LOG("gles1(%p): glIsBuffer(buffer:%u )", stream, var_buffer);
1981 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsBuffer(var_buffer);
1982 			if (useChecksum) {
1983 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
1984 			}
1985 			stream->flush();
1986 			SET_LASTCALL("glIsBuffer");
1987 			android::base::endTrace();
1988 			break;
1989 		}
1990 		case OP_glIsEnabled: {
1991 			android::base::beginTrace("glIsEnabled decode");
1992 			GLenum var_cap = Unpack<GLenum,uint32_t>(ptr + 8);
1993 			if (useChecksum) {
1994 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
1995 					"gles1_decoder_context_t::decode, OP_glIsEnabled: GL checksumCalculator failure\n");
1996 			}
1997 			size_t totalTmpSize = sizeof(GLboolean);
1998 			totalTmpSize += checksumSize;
1999 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2000 			#ifdef CHECK_GL_ERRORS
2001 			GLint err = this->glGetError();
2002 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsEnabled\n", err);
2003 			#endif
2004 			DECODER_DEBUG_LOG("gles1(%p): glIsEnabled(cap:0x%08x )", stream, var_cap);
2005 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsEnabled(var_cap);
2006 			if (useChecksum) {
2007 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2008 			}
2009 			stream->flush();
2010 			SET_LASTCALL("glIsEnabled");
2011 			android::base::endTrace();
2012 			break;
2013 		}
2014 		case OP_glIsTexture: {
2015 			android::base::beginTrace("glIsTexture decode");
2016 			GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
2017 			if (useChecksum) {
2018 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2019 					"gles1_decoder_context_t::decode, OP_glIsTexture: GL checksumCalculator failure\n");
2020 			}
2021 			size_t totalTmpSize = sizeof(GLboolean);
2022 			totalTmpSize += checksumSize;
2023 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2024 			#ifdef CHECK_GL_ERRORS
2025 			GLint err = this->glGetError();
2026 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsTexture\n", err);
2027 			#endif
2028 			DECODER_DEBUG_LOG("gles1(%p): glIsTexture(texture:%u )", stream, var_texture);
2029 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsTexture(var_texture);
2030 			if (useChecksum) {
2031 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2032 			}
2033 			stream->flush();
2034 			SET_LASTCALL("glIsTexture");
2035 			android::base::endTrace();
2036 			break;
2037 		}
2038 		case OP_glLightModelx: {
2039 			android::base::beginTrace("glLightModelx decode");
2040 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2041 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2042 			if (useChecksum) {
2043 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2044 					"gles1_decoder_context_t::decode, OP_glLightModelx: GL checksumCalculator failure\n");
2045 			}
2046 			#ifdef CHECK_GL_ERRORS
2047 			GLint err = this->glGetError();
2048 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelx\n", err);
2049 			#endif
2050 			DECODER_DEBUG_LOG("gles1(%p): glLightModelx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
2051 			this->glLightModelx(var_pname, var_param);
2052 			SET_LASTCALL("glLightModelx");
2053 			android::base::endTrace();
2054 			break;
2055 		}
2056 		case OP_glLightModelxv: {
2057 			android::base::beginTrace("glLightModelxv decode");
2058 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2059 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
2060 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
2061 			if (useChecksum) {
2062 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
2063 					"gles1_decoder_context_t::decode, OP_glLightModelxv: GL checksumCalculator failure\n");
2064 			}
2065 			#ifdef CHECK_GL_ERRORS
2066 			GLint err = this->glGetError();
2067 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxv\n", err);
2068 			#endif
2069 			DECODER_DEBUG_LOG("gles1(%p): glLightModelxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2070 			this->glLightModelxv(var_pname, (const GLfixed*)(inptr_params.get()));
2071 			SET_LASTCALL("glLightModelxv");
2072 			android::base::endTrace();
2073 			break;
2074 		}
2075 		case OP_glLightx: {
2076 			android::base::beginTrace("glLightx decode");
2077 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
2078 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2079 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2080 			if (useChecksum) {
2081 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2082 					"gles1_decoder_context_t::decode, OP_glLightx: GL checksumCalculator failure\n");
2083 			}
2084 			#ifdef CHECK_GL_ERRORS
2085 			GLint err = this->glGetError();
2086 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightx\n", err);
2087 			#endif
2088 			DECODER_DEBUG_LOG("gles1(%p): glLightx(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
2089 			this->glLightx(var_light, var_pname, var_param);
2090 			SET_LASTCALL("glLightx");
2091 			android::base::endTrace();
2092 			break;
2093 		}
2094 		case OP_glLightxv: {
2095 			android::base::beginTrace("glLightxv decode");
2096 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
2097 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2098 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2099 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2100 			if (useChecksum) {
2101 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2102 					"gles1_decoder_context_t::decode, OP_glLightxv: GL checksumCalculator failure\n");
2103 			}
2104 			#ifdef CHECK_GL_ERRORS
2105 			GLint err = this->glGetError();
2106 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxv\n", err);
2107 			#endif
2108 			DECODER_DEBUG_LOG("gles1(%p): glLightxv(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2109 			this->glLightxv(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
2110 			SET_LASTCALL("glLightxv");
2111 			android::base::endTrace();
2112 			break;
2113 		}
2114 		case OP_glLineWidthx: {
2115 			android::base::beginTrace("glLineWidthx decode");
2116 			GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
2117 			if (useChecksum) {
2118 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2119 					"gles1_decoder_context_t::decode, OP_glLineWidthx: GL checksumCalculator failure\n");
2120 			}
2121 			#ifdef CHECK_GL_ERRORS
2122 			GLint err = this->glGetError();
2123 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthx\n", err);
2124 			#endif
2125 			DECODER_DEBUG_LOG("gles1(%p): glLineWidthx(width:0x%08x )", stream, var_width);
2126 			this->glLineWidthx(var_width);
2127 			SET_LASTCALL("glLineWidthx");
2128 			android::base::endTrace();
2129 			break;
2130 		}
2131 		case OP_glLoadIdentity: {
2132 			android::base::beginTrace("glLoadIdentity decode");
2133 			if (useChecksum) {
2134 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2135 					"gles1_decoder_context_t::decode, OP_glLoadIdentity: GL checksumCalculator failure\n");
2136 			}
2137 			#ifdef CHECK_GL_ERRORS
2138 			GLint err = this->glGetError();
2139 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadIdentity\n", err);
2140 			#endif
2141 			DECODER_DEBUG_LOG("gles1(%p): glLoadIdentity()", stream);
2142 			this->glLoadIdentity();
2143 			SET_LASTCALL("glLoadIdentity");
2144 			android::base::endTrace();
2145 			break;
2146 		}
2147 		case OP_glLoadMatrixx: {
2148 			android::base::beginTrace("glLoadMatrixx decode");
2149 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
2150 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
2151 			if (useChecksum) {
2152 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
2153 					"gles1_decoder_context_t::decode, OP_glLoadMatrixx: GL checksumCalculator failure\n");
2154 			}
2155 			#ifdef CHECK_GL_ERRORS
2156 			GLint err = this->glGetError();
2157 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixx\n", err);
2158 			#endif
2159 			DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
2160 			this->glLoadMatrixx((const GLfixed*)(inptr_m.get()));
2161 			SET_LASTCALL("glLoadMatrixx");
2162 			android::base::endTrace();
2163 			break;
2164 		}
2165 		case OP_glLogicOp: {
2166 			android::base::beginTrace("glLogicOp decode");
2167 			GLenum var_opcode = Unpack<GLenum,uint32_t>(ptr + 8);
2168 			if (useChecksum) {
2169 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2170 					"gles1_decoder_context_t::decode, OP_glLogicOp: GL checksumCalculator failure\n");
2171 			}
2172 			#ifdef CHECK_GL_ERRORS
2173 			GLint err = this->glGetError();
2174 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLogicOp\n", err);
2175 			#endif
2176 			DECODER_DEBUG_LOG("gles1(%p): glLogicOp(opcode:0x%08x )", stream, var_opcode);
2177 			this->glLogicOp(var_opcode);
2178 			SET_LASTCALL("glLogicOp");
2179 			android::base::endTrace();
2180 			break;
2181 		}
2182 		case OP_glMaterialx: {
2183 			android::base::beginTrace("glMaterialx decode");
2184 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
2185 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2186 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2187 			if (useChecksum) {
2188 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2189 					"gles1_decoder_context_t::decode, OP_glMaterialx: GL checksumCalculator failure\n");
2190 			}
2191 			#ifdef CHECK_GL_ERRORS
2192 			GLint err = this->glGetError();
2193 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialx\n", err);
2194 			#endif
2195 			DECODER_DEBUG_LOG("gles1(%p): glMaterialx(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
2196 			this->glMaterialx(var_face, var_pname, var_param);
2197 			SET_LASTCALL("glMaterialx");
2198 			android::base::endTrace();
2199 			break;
2200 		}
2201 		case OP_glMaterialxv: {
2202 			android::base::beginTrace("glMaterialxv decode");
2203 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
2204 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2205 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2206 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2207 			if (useChecksum) {
2208 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2209 					"gles1_decoder_context_t::decode, OP_glMaterialxv: GL checksumCalculator failure\n");
2210 			}
2211 			#ifdef CHECK_GL_ERRORS
2212 			GLint err = this->glGetError();
2213 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxv\n", err);
2214 			#endif
2215 			DECODER_DEBUG_LOG("gles1(%p): glMaterialxv(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2216 			this->glMaterialxv(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
2217 			SET_LASTCALL("glMaterialxv");
2218 			android::base::endTrace();
2219 			break;
2220 		}
2221 		case OP_glMatrixMode: {
2222 			android::base::beginTrace("glMatrixMode decode");
2223 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
2224 			if (useChecksum) {
2225 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2226 					"gles1_decoder_context_t::decode, OP_glMatrixMode: GL checksumCalculator failure\n");
2227 			}
2228 			#ifdef CHECK_GL_ERRORS
2229 			GLint err = this->glGetError();
2230 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixMode\n", err);
2231 			#endif
2232 			DECODER_DEBUG_LOG("gles1(%p): glMatrixMode(mode:0x%08x )", stream, var_mode);
2233 			this->glMatrixMode(var_mode);
2234 			SET_LASTCALL("glMatrixMode");
2235 			android::base::endTrace();
2236 			break;
2237 		}
2238 		case OP_glMultMatrixx: {
2239 			android::base::beginTrace("glMultMatrixx decode");
2240 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
2241 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
2242 			if (useChecksum) {
2243 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
2244 					"gles1_decoder_context_t::decode, OP_glMultMatrixx: GL checksumCalculator failure\n");
2245 			}
2246 			#ifdef CHECK_GL_ERRORS
2247 			GLint err = this->glGetError();
2248 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixx\n", err);
2249 			#endif
2250 			DECODER_DEBUG_LOG("gles1(%p): glMultMatrixx(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
2251 			this->glMultMatrixx((const GLfixed*)(inptr_m.get()));
2252 			SET_LASTCALL("glMultMatrixx");
2253 			android::base::endTrace();
2254 			break;
2255 		}
2256 		case OP_glMultiTexCoord4x: {
2257 			android::base::beginTrace("glMultiTexCoord4x decode");
2258 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2259 			GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2260 			GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2261 			GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2262 			GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2263 			if (useChecksum) {
2264 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
2265 					"gles1_decoder_context_t::decode, OP_glMultiTexCoord4x: GL checksumCalculator failure\n");
2266 			}
2267 			#ifdef CHECK_GL_ERRORS
2268 			GLint err = this->glGetError();
2269 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4x\n", err);
2270 			#endif
2271 			DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4x(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
2272 			this->glMultiTexCoord4x(var_target, var_s, var_t, var_r, var_q);
2273 			SET_LASTCALL("glMultiTexCoord4x");
2274 			android::base::endTrace();
2275 			break;
2276 		}
2277 		case OP_glNormal3x: {
2278 			android::base::beginTrace("glNormal3x decode");
2279 			GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
2280 			GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2281 			GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2282 			if (useChecksum) {
2283 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2284 					"gles1_decoder_context_t::decode, OP_glNormal3x: GL checksumCalculator failure\n");
2285 			}
2286 			#ifdef CHECK_GL_ERRORS
2287 			GLint err = this->glGetError();
2288 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3x\n", err);
2289 			#endif
2290 			DECODER_DEBUG_LOG("gles1(%p): glNormal3x(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
2291 			this->glNormal3x(var_nx, var_ny, var_nz);
2292 			SET_LASTCALL("glNormal3x");
2293 			android::base::endTrace();
2294 			break;
2295 		}
2296 		case OP_glNormalPointer: {
2297 			android::base::beginTrace("glNormalPointer decode");
2298 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
2299 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
2300 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2301 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
2302 			if (useChecksum) {
2303 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
2304 					"gles1_decoder_context_t::decode, OP_glNormalPointer: GL checksumCalculator failure\n");
2305 			}
2306 			#ifdef CHECK_GL_ERRORS
2307 			GLint err = this->glGetError();
2308 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointer\n", err);
2309 			#endif
2310 			DECODER_DEBUG_LOG("gles1(%p): glNormalPointer(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2311 			this->glNormalPointer(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2312 			SET_LASTCALL("glNormalPointer");
2313 			android::base::endTrace();
2314 			break;
2315 		}
2316 		case OP_glOrthox: {
2317 			android::base::beginTrace("glOrthox decode");
2318 			GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
2319 			GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2320 			GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2321 			GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2322 			GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2323 			GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2324 			if (useChecksum) {
2325 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
2326 					"gles1_decoder_context_t::decode, OP_glOrthox: GL checksumCalculator failure\n");
2327 			}
2328 			#ifdef CHECK_GL_ERRORS
2329 			GLint err = this->glGetError();
2330 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthox\n", err);
2331 			#endif
2332 			DECODER_DEBUG_LOG("gles1(%p): glOrthox(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
2333 			this->glOrthox(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
2334 			SET_LASTCALL("glOrthox");
2335 			android::base::endTrace();
2336 			break;
2337 		}
2338 		case OP_glPixelStorei: {
2339 			android::base::beginTrace("glPixelStorei decode");
2340 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2341 			GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2342 			if (useChecksum) {
2343 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2344 					"gles1_decoder_context_t::decode, OP_glPixelStorei: GL checksumCalculator failure\n");
2345 			}
2346 			#ifdef CHECK_GL_ERRORS
2347 			GLint err = this->glGetError();
2348 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPixelStorei\n", err);
2349 			#endif
2350 			DECODER_DEBUG_LOG("gles1(%p): glPixelStorei(pname:0x%08x param:%d )", stream, var_pname, var_param);
2351 			this->glPixelStorei(var_pname, var_param);
2352 			SET_LASTCALL("glPixelStorei");
2353 			android::base::endTrace();
2354 			break;
2355 		}
2356 		case OP_glPointParameterx: {
2357 			android::base::beginTrace("glPointParameterx decode");
2358 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2359 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2360 			if (useChecksum) {
2361 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2362 					"gles1_decoder_context_t::decode, OP_glPointParameterx: GL checksumCalculator failure\n");
2363 			}
2364 			#ifdef CHECK_GL_ERRORS
2365 			GLint err = this->glGetError();
2366 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterx\n", err);
2367 			#endif
2368 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterx(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
2369 			this->glPointParameterx(var_pname, var_param);
2370 			SET_LASTCALL("glPointParameterx");
2371 			android::base::endTrace();
2372 			break;
2373 		}
2374 		case OP_glPointParameterxv: {
2375 			android::base::beginTrace("glPointParameterxv decode");
2376 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
2377 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
2378 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
2379 			if (useChecksum) {
2380 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
2381 					"gles1_decoder_context_t::decode, OP_glPointParameterxv: GL checksumCalculator failure\n");
2382 			}
2383 			#ifdef CHECK_GL_ERRORS
2384 			GLint err = this->glGetError();
2385 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxv\n", err);
2386 			#endif
2387 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterxv(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2388 			this->glPointParameterxv(var_pname, (const GLfixed*)(inptr_params.get()));
2389 			SET_LASTCALL("glPointParameterxv");
2390 			android::base::endTrace();
2391 			break;
2392 		}
2393 		case OP_glPointSizex: {
2394 			android::base::beginTrace("glPointSizex decode");
2395 			GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
2396 			if (useChecksum) {
2397 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2398 					"gles1_decoder_context_t::decode, OP_glPointSizex: GL checksumCalculator failure\n");
2399 			}
2400 			#ifdef CHECK_GL_ERRORS
2401 			GLint err = this->glGetError();
2402 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizex\n", err);
2403 			#endif
2404 			DECODER_DEBUG_LOG("gles1(%p): glPointSizex(size:0x%08x )", stream, var_size);
2405 			this->glPointSizex(var_size);
2406 			SET_LASTCALL("glPointSizex");
2407 			android::base::endTrace();
2408 			break;
2409 		}
2410 		case OP_glPolygonOffsetx: {
2411 			android::base::beginTrace("glPolygonOffsetx decode");
2412 			GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
2413 			GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2414 			if (useChecksum) {
2415 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
2416 					"gles1_decoder_context_t::decode, OP_glPolygonOffsetx: GL checksumCalculator failure\n");
2417 			}
2418 			#ifdef CHECK_GL_ERRORS
2419 			GLint err = this->glGetError();
2420 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetx\n", err);
2421 			#endif
2422 			DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetx(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
2423 			this->glPolygonOffsetx(var_factor, var_units);
2424 			SET_LASTCALL("glPolygonOffsetx");
2425 			android::base::endTrace();
2426 			break;
2427 		}
2428 		case OP_glPopMatrix: {
2429 			android::base::beginTrace("glPopMatrix decode");
2430 			if (useChecksum) {
2431 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2432 					"gles1_decoder_context_t::decode, OP_glPopMatrix: GL checksumCalculator failure\n");
2433 			}
2434 			#ifdef CHECK_GL_ERRORS
2435 			GLint err = this->glGetError();
2436 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPopMatrix\n", err);
2437 			#endif
2438 			DECODER_DEBUG_LOG("gles1(%p): glPopMatrix()", stream);
2439 			this->glPopMatrix();
2440 			SET_LASTCALL("glPopMatrix");
2441 			android::base::endTrace();
2442 			break;
2443 		}
2444 		case OP_glPushMatrix: {
2445 			android::base::beginTrace("glPushMatrix decode");
2446 			if (useChecksum) {
2447 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
2448 					"gles1_decoder_context_t::decode, OP_glPushMatrix: GL checksumCalculator failure\n");
2449 			}
2450 			#ifdef CHECK_GL_ERRORS
2451 			GLint err = this->glGetError();
2452 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPushMatrix\n", err);
2453 			#endif
2454 			DECODER_DEBUG_LOG("gles1(%p): glPushMatrix()", stream);
2455 			this->glPushMatrix();
2456 			SET_LASTCALL("glPushMatrix");
2457 			android::base::endTrace();
2458 			break;
2459 		}
2460 		case OP_glReadPixels: {
2461 			android::base::beginTrace("glReadPixels decode");
2462 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2463 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2464 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2465 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2466 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2467 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2468 			uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2469 			if (useChecksum) {
2470 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
2471 					"gles1_decoder_context_t::decode, OP_glReadPixels: GL checksumCalculator failure\n");
2472 			}
2473 			size_t totalTmpSize = size_pixels;
2474 			totalTmpSize += checksumSize;
2475 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
2476 			OutputBuffer outptr_pixels(&tmpBuf[0], size_pixels);
2477 			#ifdef CHECK_GL_ERRORS
2478 			GLint err = this->glGetError();
2479 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadPixels\n", err);
2480 			#endif
2481 			DECODER_DEBUG_LOG("gles1(%p): glReadPixels(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()), size_pixels);
2482 			this->glReadPixels(var_x, var_y, var_width, var_height, var_format, var_type, (GLvoid*)(outptr_pixels.get()));
2483 			outptr_pixels.flush();
2484 			if (useChecksum) {
2485 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
2486 			}
2487 			stream->flush();
2488 			SET_LASTCALL("glReadPixels");
2489 			android::base::endTrace();
2490 			break;
2491 		}
2492 		case OP_glRotatex: {
2493 			android::base::beginTrace("glRotatex decode");
2494 			GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
2495 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2496 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2497 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
2498 			if (useChecksum) {
2499 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2500 					"gles1_decoder_context_t::decode, OP_glRotatex: GL checksumCalculator failure\n");
2501 			}
2502 			#ifdef CHECK_GL_ERRORS
2503 			GLint err = this->glGetError();
2504 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatex\n", err);
2505 			#endif
2506 			DECODER_DEBUG_LOG("gles1(%p): glRotatex(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
2507 			this->glRotatex(var_angle, var_x, var_y, var_z);
2508 			SET_LASTCALL("glRotatex");
2509 			android::base::endTrace();
2510 			break;
2511 		}
2512 		case OP_glSampleCoverage: {
2513 			android::base::beginTrace("glSampleCoverage decode");
2514 			GLclampf var_value = Unpack<GLclampf,uint32_t>(ptr + 8);
2515 			GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
2516 			if (useChecksum) {
2517 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
2518 					"gles1_decoder_context_t::decode, OP_glSampleCoverage: GL checksumCalculator failure\n");
2519 			}
2520 			#ifdef CHECK_GL_ERRORS
2521 			GLint err = this->glGetError();
2522 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoverage\n", err);
2523 			#endif
2524 			DECODER_DEBUG_LOG("gles1(%p): glSampleCoverage(value:%f invert:%d )", stream, var_value, var_invert);
2525 			this->glSampleCoverage(var_value, var_invert);
2526 			SET_LASTCALL("glSampleCoverage");
2527 			android::base::endTrace();
2528 			break;
2529 		}
2530 		case OP_glSampleCoveragex: {
2531 			android::base::beginTrace("glSampleCoveragex decode");
2532 			GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
2533 			GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
2534 			if (useChecksum) {
2535 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
2536 					"gles1_decoder_context_t::decode, OP_glSampleCoveragex: GL checksumCalculator failure\n");
2537 			}
2538 			#ifdef CHECK_GL_ERRORS
2539 			GLint err = this->glGetError();
2540 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragex\n", err);
2541 			#endif
2542 			DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragex(value:0x%08x invert:%d )", stream, var_value, var_invert);
2543 			this->glSampleCoveragex(var_value, var_invert);
2544 			SET_LASTCALL("glSampleCoveragex");
2545 			android::base::endTrace();
2546 			break;
2547 		}
2548 		case OP_glScalex: {
2549 			android::base::beginTrace("glScalex decode");
2550 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
2551 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2552 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2553 			if (useChecksum) {
2554 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2555 					"gles1_decoder_context_t::decode, OP_glScalex: GL checksumCalculator failure\n");
2556 			}
2557 			#ifdef CHECK_GL_ERRORS
2558 			GLint err = this->glGetError();
2559 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalex\n", err);
2560 			#endif
2561 			DECODER_DEBUG_LOG("gles1(%p): glScalex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
2562 			this->glScalex(var_x, var_y, var_z);
2563 			SET_LASTCALL("glScalex");
2564 			android::base::endTrace();
2565 			break;
2566 		}
2567 		case OP_glScissor: {
2568 			android::base::beginTrace("glScissor decode");
2569 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2570 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2571 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2572 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2573 			if (useChecksum) {
2574 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2575 					"gles1_decoder_context_t::decode, OP_glScissor: GL checksumCalculator failure\n");
2576 			}
2577 			#ifdef CHECK_GL_ERRORS
2578 			GLint err = this->glGetError();
2579 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScissor\n", err);
2580 			#endif
2581 			DECODER_DEBUG_LOG("gles1(%p): glScissor(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
2582 			this->glScissor(var_x, var_y, var_width, var_height);
2583 			SET_LASTCALL("glScissor");
2584 			android::base::endTrace();
2585 			break;
2586 		}
2587 		case OP_glShadeModel: {
2588 			android::base::beginTrace("glShadeModel decode");
2589 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
2590 			if (useChecksum) {
2591 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2592 					"gles1_decoder_context_t::decode, OP_glShadeModel: GL checksumCalculator failure\n");
2593 			}
2594 			#ifdef CHECK_GL_ERRORS
2595 			GLint err = this->glGetError();
2596 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glShadeModel\n", err);
2597 			#endif
2598 			DECODER_DEBUG_LOG("gles1(%p): glShadeModel(mode:0x%08x )", stream, var_mode);
2599 			this->glShadeModel(var_mode);
2600 			SET_LASTCALL("glShadeModel");
2601 			android::base::endTrace();
2602 			break;
2603 		}
2604 		case OP_glStencilFunc: {
2605 			android::base::beginTrace("glStencilFunc decode");
2606 			GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
2607 			GLint var_ref = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2608 			GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
2609 			if (useChecksum) {
2610 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2611 					"gles1_decoder_context_t::decode, OP_glStencilFunc: GL checksumCalculator failure\n");
2612 			}
2613 			#ifdef CHECK_GL_ERRORS
2614 			GLint err = this->glGetError();
2615 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilFunc\n", err);
2616 			#endif
2617 			DECODER_DEBUG_LOG("gles1(%p): glStencilFunc(func:0x%08x ref:%d mask:%u )", stream, var_func, var_ref, var_mask);
2618 			this->glStencilFunc(var_func, var_ref, var_mask);
2619 			SET_LASTCALL("glStencilFunc");
2620 			android::base::endTrace();
2621 			break;
2622 		}
2623 		case OP_glStencilMask: {
2624 			android::base::beginTrace("glStencilMask decode");
2625 			GLuint var_mask = Unpack<GLuint,uint32_t>(ptr + 8);
2626 			if (useChecksum) {
2627 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
2628 					"gles1_decoder_context_t::decode, OP_glStencilMask: GL checksumCalculator failure\n");
2629 			}
2630 			#ifdef CHECK_GL_ERRORS
2631 			GLint err = this->glGetError();
2632 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilMask\n", err);
2633 			#endif
2634 			DECODER_DEBUG_LOG("gles1(%p): glStencilMask(mask:%u )", stream, var_mask);
2635 			this->glStencilMask(var_mask);
2636 			SET_LASTCALL("glStencilMask");
2637 			android::base::endTrace();
2638 			break;
2639 		}
2640 		case OP_glStencilOp: {
2641 			android::base::beginTrace("glStencilOp decode");
2642 			GLenum var_fail = Unpack<GLenum,uint32_t>(ptr + 8);
2643 			GLenum var_zfail = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2644 			GLenum var_zpass = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
2645 			if (useChecksum) {
2646 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2647 					"gles1_decoder_context_t::decode, OP_glStencilOp: GL checksumCalculator failure\n");
2648 			}
2649 			#ifdef CHECK_GL_ERRORS
2650 			GLint err = this->glGetError();
2651 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStencilOp\n", err);
2652 			#endif
2653 			DECODER_DEBUG_LOG("gles1(%p): glStencilOp(fail:0x%08x zfail:0x%08x zpass:0x%08x )", stream, var_fail, var_zfail, var_zpass);
2654 			this->glStencilOp(var_fail, var_zfail, var_zpass);
2655 			SET_LASTCALL("glStencilOp");
2656 			android::base::endTrace();
2657 			break;
2658 		}
2659 		case OP_glTexCoordPointer: {
2660 			android::base::beginTrace("glTexCoordPointer decode");
2661 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2662 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2663 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2664 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
2665 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
2666 			if (useChecksum) {
2667 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
2668 					"gles1_decoder_context_t::decode, OP_glTexCoordPointer: GL checksumCalculator failure\n");
2669 			}
2670 			#ifdef CHECK_GL_ERRORS
2671 			GLint err = this->glGetError();
2672 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointer\n", err);
2673 			#endif
2674 			DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2675 			this->glTexCoordPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2676 			SET_LASTCALL("glTexCoordPointer");
2677 			android::base::endTrace();
2678 			break;
2679 		}
2680 		case OP_glTexEnvi: {
2681 			android::base::beginTrace("glTexEnvi decode");
2682 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2683 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2684 			GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2685 			if (useChecksum) {
2686 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2687 					"gles1_decoder_context_t::decode, OP_glTexEnvi: GL checksumCalculator failure\n");
2688 			}
2689 			#ifdef CHECK_GL_ERRORS
2690 			GLint err = this->glGetError();
2691 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvi\n", err);
2692 			#endif
2693 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvi(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
2694 			this->glTexEnvi(var_target, var_pname, var_param);
2695 			SET_LASTCALL("glTexEnvi");
2696 			android::base::endTrace();
2697 			break;
2698 		}
2699 		case OP_glTexEnvx: {
2700 			android::base::beginTrace("glTexEnvx decode");
2701 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2702 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2703 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2704 			if (useChecksum) {
2705 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2706 					"gles1_decoder_context_t::decode, OP_glTexEnvx: GL checksumCalculator failure\n");
2707 			}
2708 			#ifdef CHECK_GL_ERRORS
2709 			GLint err = this->glGetError();
2710 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvx\n", err);
2711 			#endif
2712 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
2713 			this->glTexEnvx(var_target, var_pname, var_param);
2714 			SET_LASTCALL("glTexEnvx");
2715 			android::base::endTrace();
2716 			break;
2717 		}
2718 		case OP_glTexEnviv: {
2719 			android::base::beginTrace("glTexEnviv decode");
2720 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2721 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2722 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2723 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2724 			if (useChecksum) {
2725 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2726 					"gles1_decoder_context_t::decode, OP_glTexEnviv: GL checksumCalculator failure\n");
2727 			}
2728 			#ifdef CHECK_GL_ERRORS
2729 			GLint err = this->glGetError();
2730 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnviv\n", err);
2731 			#endif
2732 			DECODER_DEBUG_LOG("gles1(%p): glTexEnviv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
2733 			this->glTexEnviv(var_target, var_pname, (const GLint*)(inptr_params.get()));
2734 			SET_LASTCALL("glTexEnviv");
2735 			android::base::endTrace();
2736 			break;
2737 		}
2738 		case OP_glTexEnvxv: {
2739 			android::base::beginTrace("glTexEnvxv decode");
2740 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2741 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2742 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2743 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2744 			if (useChecksum) {
2745 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2746 					"gles1_decoder_context_t::decode, OP_glTexEnvxv: GL checksumCalculator failure\n");
2747 			}
2748 			#ifdef CHECK_GL_ERRORS
2749 			GLint err = this->glGetError();
2750 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxv\n", err);
2751 			#endif
2752 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2753 			this->glTexEnvxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
2754 			SET_LASTCALL("glTexEnvxv");
2755 			android::base::endTrace();
2756 			break;
2757 		}
2758 		case OP_glTexImage2D: {
2759 			android::base::beginTrace("glTexImage2D decode");
2760 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2761 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2762 			GLint var_internalformat = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2763 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2764 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2765 			GLint var_border = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2766 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2767 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2768 			uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2769 			InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
2770 			if (useChecksum) {
2771 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
2772 					"gles1_decoder_context_t::decode, OP_glTexImage2D: GL checksumCalculator failure\n");
2773 			}
2774 			#ifdef CHECK_GL_ERRORS
2775 			GLint err = this->glGetError();
2776 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexImage2D\n", err);
2777 			#endif
2778 			DECODER_DEBUG_LOG("gles1(%p): glTexImage2D(target:0x%08x level:%d internalformat:%d width:%d height:%d border:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
2779 			this->glTexImage2D(var_target, var_level, var_internalformat, var_width, var_height, var_border, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
2780 			SET_LASTCALL("glTexImage2D");
2781 			android::base::endTrace();
2782 			break;
2783 		}
2784 		case OP_glTexParameteri: {
2785 			android::base::beginTrace("glTexParameteri decode");
2786 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2787 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2788 			GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2789 			if (useChecksum) {
2790 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2791 					"gles1_decoder_context_t::decode, OP_glTexParameteri: GL checksumCalculator failure\n");
2792 			}
2793 			#ifdef CHECK_GL_ERRORS
2794 			GLint err = this->glGetError();
2795 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteri\n", err);
2796 			#endif
2797 			DECODER_DEBUG_LOG("gles1(%p): glTexParameteri(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
2798 			this->glTexParameteri(var_target, var_pname, var_param);
2799 			SET_LASTCALL("glTexParameteri");
2800 			android::base::endTrace();
2801 			break;
2802 		}
2803 		case OP_glTexParameterx: {
2804 			android::base::beginTrace("glTexParameterx decode");
2805 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2806 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2807 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2808 			if (useChecksum) {
2809 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2810 					"gles1_decoder_context_t::decode, OP_glTexParameterx: GL checksumCalculator failure\n");
2811 			}
2812 			#ifdef CHECK_GL_ERRORS
2813 			GLint err = this->glGetError();
2814 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterx\n", err);
2815 			#endif
2816 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterx(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
2817 			this->glTexParameterx(var_target, var_pname, var_param);
2818 			SET_LASTCALL("glTexParameterx");
2819 			android::base::endTrace();
2820 			break;
2821 		}
2822 		case OP_glTexParameteriv: {
2823 			android::base::beginTrace("glTexParameteriv decode");
2824 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2825 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2826 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2827 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2828 			if (useChecksum) {
2829 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2830 					"gles1_decoder_context_t::decode, OP_glTexParameteriv: GL checksumCalculator failure\n");
2831 			}
2832 			#ifdef CHECK_GL_ERRORS
2833 			GLint err = this->glGetError();
2834 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameteriv\n", err);
2835 			#endif
2836 			DECODER_DEBUG_LOG("gles1(%p): glTexParameteriv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLint*)(inptr_params.get()), size_params);
2837 			this->glTexParameteriv(var_target, var_pname, (const GLint*)(inptr_params.get()));
2838 			SET_LASTCALL("glTexParameteriv");
2839 			android::base::endTrace();
2840 			break;
2841 		}
2842 		case OP_glTexParameterxv: {
2843 			android::base::beginTrace("glTexParameterxv decode");
2844 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2845 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2846 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2847 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
2848 			if (useChecksum) {
2849 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
2850 					"gles1_decoder_context_t::decode, OP_glTexParameterxv: GL checksumCalculator failure\n");
2851 			}
2852 			#ifdef CHECK_GL_ERRORS
2853 			GLint err = this->glGetError();
2854 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxv\n", err);
2855 			#endif
2856 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterxv(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
2857 			this->glTexParameterxv(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
2858 			SET_LASTCALL("glTexParameterxv");
2859 			android::base::endTrace();
2860 			break;
2861 		}
2862 		case OP_glTexSubImage2D: {
2863 			android::base::beginTrace("glTexSubImage2D decode");
2864 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
2865 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2866 			GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
2867 			GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2868 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
2869 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
2870 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
2871 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2872 			uint32_t size_pixels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
2873 			InputBuffer inptr_pixels(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, size_pixels);
2874 			if (useChecksum) {
2875 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + size_pixels, checksumSize,
2876 					"gles1_decoder_context_t::decode, OP_glTexSubImage2D: GL checksumCalculator failure\n");
2877 			}
2878 			#ifdef CHECK_GL_ERRORS
2879 			GLint err = this->glGetError();
2880 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexSubImage2D\n", err);
2881 			#endif
2882 			DECODER_DEBUG_LOG("gles1(%p): glTexSubImage2D(target:0x%08x level:%d xoffset:%d yoffset:%d width:%d height:%d format:0x%08x type:0x%08x pixels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, (const GLvoid*)(inptr_pixels.get()), size_pixels);
2883 			this->glTexSubImage2D(var_target, var_level, var_xoffset, var_yoffset, var_width, var_height, var_format, var_type, size_pixels == 0 ? nullptr : (const GLvoid*)(inptr_pixels.get()));
2884 			SET_LASTCALL("glTexSubImage2D");
2885 			android::base::endTrace();
2886 			break;
2887 		}
2888 		case OP_glTranslatex: {
2889 			android::base::beginTrace("glTranslatex decode");
2890 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
2891 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
2892 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
2893 			if (useChecksum) {
2894 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
2895 					"gles1_decoder_context_t::decode, OP_glTranslatex: GL checksumCalculator failure\n");
2896 			}
2897 			#ifdef CHECK_GL_ERRORS
2898 			GLint err = this->glGetError();
2899 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatex\n", err);
2900 			#endif
2901 			DECODER_DEBUG_LOG("gles1(%p): glTranslatex(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
2902 			this->glTranslatex(var_x, var_y, var_z);
2903 			SET_LASTCALL("glTranslatex");
2904 			android::base::endTrace();
2905 			break;
2906 		}
2907 		case OP_glVertexPointer: {
2908 			android::base::beginTrace("glVertexPointer decode");
2909 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2910 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2911 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2912 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
2913 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
2914 			if (useChecksum) {
2915 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
2916 					"gles1_decoder_context_t::decode, OP_glVertexPointer: GL checksumCalculator failure\n");
2917 			}
2918 			#ifdef CHECK_GL_ERRORS
2919 			GLint err = this->glGetError();
2920 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointer\n", err);
2921 			#endif
2922 			DECODER_DEBUG_LOG("gles1(%p): glVertexPointer(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2923 			this->glVertexPointer(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2924 			SET_LASTCALL("glVertexPointer");
2925 			android::base::endTrace();
2926 			break;
2927 		}
2928 		case OP_glViewport: {
2929 			android::base::beginTrace("glViewport decode");
2930 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
2931 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
2932 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2933 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
2934 			if (useChecksum) {
2935 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2936 					"gles1_decoder_context_t::decode, OP_glViewport: GL checksumCalculator failure\n");
2937 			}
2938 			#ifdef CHECK_GL_ERRORS
2939 			GLint err = this->glGetError();
2940 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glViewport\n", err);
2941 			#endif
2942 			DECODER_DEBUG_LOG("gles1(%p): glViewport(x:%d y:%d width:%d height:%d )", stream, var_x, var_y, var_width, var_height);
2943 			this->glViewport(var_x, var_y, var_width, var_height);
2944 			SET_LASTCALL("glViewport");
2945 			android::base::endTrace();
2946 			break;
2947 		}
2948 		case OP_glPointSizePointerOES: {
2949 			android::base::beginTrace("glPointSizePointerOES decode");
2950 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
2951 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
2952 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
2953 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4, size_pointer);
2954 			if (useChecksum) {
2955 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + size_pointer, checksumSize,
2956 					"gles1_decoder_context_t::decode, OP_glPointSizePointerOES: GL checksumCalculator failure\n");
2957 			}
2958 			#ifdef CHECK_GL_ERRORS
2959 			GLint err = this->glGetError();
2960 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOES\n", err);
2961 			#endif
2962 			DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOES(type:0x%08x stride:%d pointer:%p(%u) )", stream, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
2963 			this->glPointSizePointerOES(var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
2964 			SET_LASTCALL("glPointSizePointerOES");
2965 			android::base::endTrace();
2966 			break;
2967 		}
2968 		case OP_glVertexPointerOffset: {
2969 			android::base::beginTrace("glVertexPointerOffset decode");
2970 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2971 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2972 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2973 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2974 			if (useChecksum) {
2975 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2976 					"gles1_decoder_context_t::decode, OP_glVertexPointerOffset: GL checksumCalculator failure\n");
2977 			}
2978 			#ifdef CHECK_GL_ERRORS
2979 			GLint err = this->glGetError();
2980 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerOffset\n", err);
2981 			#endif
2982 			DECODER_DEBUG_LOG("gles1(%p): glVertexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
2983 			this->glVertexPointerOffset(this, var_size, var_type, var_stride, var_offset);
2984 			SET_LASTCALL("glVertexPointerOffset");
2985 			android::base::endTrace();
2986 			break;
2987 		}
2988 		case OP_glColorPointerOffset: {
2989 			android::base::beginTrace("glColorPointerOffset decode");
2990 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
2991 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
2992 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
2993 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
2994 			if (useChecksum) {
2995 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
2996 					"gles1_decoder_context_t::decode, OP_glColorPointerOffset: GL checksumCalculator failure\n");
2997 			}
2998 			#ifdef CHECK_GL_ERRORS
2999 			GLint err = this->glGetError();
3000 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerOffset\n", err);
3001 			#endif
3002 			DECODER_DEBUG_LOG("gles1(%p): glColorPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3003 			this->glColorPointerOffset(this, var_size, var_type, var_stride, var_offset);
3004 			SET_LASTCALL("glColorPointerOffset");
3005 			android::base::endTrace();
3006 			break;
3007 		}
3008 		case OP_glNormalPointerOffset: {
3009 			android::base::beginTrace("glNormalPointerOffset decode");
3010 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3011 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3012 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
3013 			if (useChecksum) {
3014 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3015 					"gles1_decoder_context_t::decode, OP_glNormalPointerOffset: GL checksumCalculator failure\n");
3016 			}
3017 			#ifdef CHECK_GL_ERRORS
3018 			GLint err = this->glGetError();
3019 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerOffset\n", err);
3020 			#endif
3021 			DECODER_DEBUG_LOG("gles1(%p): glNormalPointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
3022 			this->glNormalPointerOffset(this, var_type, var_stride, var_offset);
3023 			SET_LASTCALL("glNormalPointerOffset");
3024 			android::base::endTrace();
3025 			break;
3026 		}
3027 		case OP_glPointSizePointerOffset: {
3028 			android::base::beginTrace("glPointSizePointerOffset decode");
3029 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3030 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3031 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
3032 			if (useChecksum) {
3033 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3034 					"gles1_decoder_context_t::decode, OP_glPointSizePointerOffset: GL checksumCalculator failure\n");
3035 			}
3036 			#ifdef CHECK_GL_ERRORS
3037 			GLint err = this->glGetError();
3038 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerOffset\n", err);
3039 			#endif
3040 			DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerOffset(type:0x%08x stride:%d offset:%u )", stream, var_type, var_stride, var_offset);
3041 			this->glPointSizePointerOffset(this, var_type, var_stride, var_offset);
3042 			SET_LASTCALL("glPointSizePointerOffset");
3043 			android::base::endTrace();
3044 			break;
3045 		}
3046 		case OP_glTexCoordPointerOffset: {
3047 			android::base::beginTrace("glTexCoordPointerOffset decode");
3048 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3049 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3050 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3051 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3052 			if (useChecksum) {
3053 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3054 					"gles1_decoder_context_t::decode, OP_glTexCoordPointerOffset: GL checksumCalculator failure\n");
3055 			}
3056 			#ifdef CHECK_GL_ERRORS
3057 			GLint err = this->glGetError();
3058 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerOffset\n", err);
3059 			#endif
3060 			DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3061 			this->glTexCoordPointerOffset(this, var_size, var_type, var_stride, var_offset);
3062 			SET_LASTCALL("glTexCoordPointerOffset");
3063 			android::base::endTrace();
3064 			break;
3065 		}
3066 		case OP_glWeightPointerOffset: {
3067 			android::base::beginTrace("glWeightPointerOffset decode");
3068 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3069 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3070 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3071 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3072 			if (useChecksum) {
3073 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3074 					"gles1_decoder_context_t::decode, OP_glWeightPointerOffset: GL checksumCalculator failure\n");
3075 			}
3076 			#ifdef CHECK_GL_ERRORS
3077 			GLint err = this->glGetError();
3078 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOffset\n", err);
3079 			#endif
3080 			DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3081 			this->glWeightPointerOffset(this, var_size, var_type, var_stride, var_offset);
3082 			SET_LASTCALL("glWeightPointerOffset");
3083 			android::base::endTrace();
3084 			break;
3085 		}
3086 		case OP_glMatrixIndexPointerOffset: {
3087 			android::base::beginTrace("glMatrixIndexPointerOffset decode");
3088 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3089 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3090 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3091 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3092 			if (useChecksum) {
3093 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3094 					"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOffset: GL checksumCalculator failure\n");
3095 			}
3096 			#ifdef CHECK_GL_ERRORS
3097 			GLint err = this->glGetError();
3098 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOffset\n", err);
3099 			#endif
3100 			DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOffset(size:%d type:0x%08x stride:%d offset:%u )", stream, var_size, var_type, var_stride, var_offset);
3101 			this->glMatrixIndexPointerOffset(this, var_size, var_type, var_stride, var_offset);
3102 			SET_LASTCALL("glMatrixIndexPointerOffset");
3103 			android::base::endTrace();
3104 			break;
3105 		}
3106 		case OP_glVertexPointerData: {
3107 			android::base::beginTrace("glVertexPointerData decode");
3108 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3109 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3110 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3111 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3112 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3113 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3114 			if (useChecksum) {
3115 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3116 					"gles1_decoder_context_t::decode, OP_glVertexPointerData: GL checksumCalculator failure\n");
3117 			}
3118 			#ifdef CHECK_GL_ERRORS
3119 			GLint err = this->glGetError();
3120 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glVertexPointerData\n", err);
3121 			#endif
3122 			DECODER_DEBUG_LOG("gles1(%p): glVertexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3123 			this->glVertexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3124 			SET_LASTCALL("glVertexPointerData");
3125 			android::base::endTrace();
3126 			break;
3127 		}
3128 		case OP_glColorPointerData: {
3129 			android::base::beginTrace("glColorPointerData decode");
3130 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3131 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3132 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3133 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3134 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3135 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3136 			if (useChecksum) {
3137 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3138 					"gles1_decoder_context_t::decode, OP_glColorPointerData: GL checksumCalculator failure\n");
3139 			}
3140 			#ifdef CHECK_GL_ERRORS
3141 			GLint err = this->glGetError();
3142 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColorPointerData\n", err);
3143 			#endif
3144 			DECODER_DEBUG_LOG("gles1(%p): glColorPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3145 			this->glColorPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3146 			SET_LASTCALL("glColorPointerData");
3147 			android::base::endTrace();
3148 			break;
3149 		}
3150 		case OP_glNormalPointerData: {
3151 			android::base::beginTrace("glNormalPointerData decode");
3152 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3153 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3154 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3155 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
3156 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
3157 			if (useChecksum) {
3158 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
3159 					"gles1_decoder_context_t::decode, OP_glNormalPointerData: GL checksumCalculator failure\n");
3160 			}
3161 			#ifdef CHECK_GL_ERRORS
3162 			GLint err = this->glGetError();
3163 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormalPointerData\n", err);
3164 			#endif
3165 			DECODER_DEBUG_LOG("gles1(%p): glNormalPointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3166 			this->glNormalPointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3167 			SET_LASTCALL("glNormalPointerData");
3168 			android::base::endTrace();
3169 			break;
3170 		}
3171 		case OP_glTexCoordPointerData: {
3172 			android::base::beginTrace("glTexCoordPointerData decode");
3173 			GLint var_unit = Unpack<GLint,uint32_t>(ptr + 8);
3174 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8 + 4);
3175 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3176 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
3177 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3178 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4 + 4, size_data);
3179 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data);
3180 			if (useChecksum) {
3181 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3182 					"gles1_decoder_context_t::decode, OP_glTexCoordPointerData: GL checksumCalculator failure\n");
3183 			}
3184 			#ifdef CHECK_GL_ERRORS
3185 			GLint err = this->glGetError();
3186 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexCoordPointerData\n", err);
3187 			#endif
3188 			DECODER_DEBUG_LOG("gles1(%p): glTexCoordPointerData(unit:%d size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3189 			this->glTexCoordPointerData(this, var_unit, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3190 			SET_LASTCALL("glTexCoordPointerData");
3191 			android::base::endTrace();
3192 			break;
3193 		}
3194 		case OP_glPointSizePointerData: {
3195 			android::base::beginTrace("glPointSizePointerData decode");
3196 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8);
3197 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3198 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3199 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4, size_data);
3200 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_data);
3201 			if (useChecksum) {
3202 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + size_data + 4, checksumSize,
3203 					"gles1_decoder_context_t::decode, OP_glPointSizePointerData: GL checksumCalculator failure\n");
3204 			}
3205 			#ifdef CHECK_GL_ERRORS
3206 			GLint err = this->glGetError();
3207 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizePointerData\n", err);
3208 			#endif
3209 			DECODER_DEBUG_LOG("gles1(%p): glPointSizePointerData(type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3210 			this->glPointSizePointerData(this, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3211 			SET_LASTCALL("glPointSizePointerData");
3212 			android::base::endTrace();
3213 			break;
3214 		}
3215 		case OP_glWeightPointerData: {
3216 			android::base::beginTrace("glWeightPointerData decode");
3217 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3218 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3219 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3220 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3221 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3222 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3223 			if (useChecksum) {
3224 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3225 					"gles1_decoder_context_t::decode, OP_glWeightPointerData: GL checksumCalculator failure\n");
3226 			}
3227 			#ifdef CHECK_GL_ERRORS
3228 			GLint err = this->glGetError();
3229 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerData\n", err);
3230 			#endif
3231 			DECODER_DEBUG_LOG("gles1(%p): glWeightPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3232 			this->glWeightPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3233 			SET_LASTCALL("glWeightPointerData");
3234 			android::base::endTrace();
3235 			break;
3236 		}
3237 		case OP_glMatrixIndexPointerData: {
3238 			android::base::beginTrace("glMatrixIndexPointerData decode");
3239 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
3240 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3241 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
3242 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3243 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3244 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3245 			if (useChecksum) {
3246 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3247 					"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerData: GL checksumCalculator failure\n");
3248 			}
3249 			#ifdef CHECK_GL_ERRORS
3250 			GLint err = this->glGetError();
3251 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerData\n", err);
3252 			#endif
3253 			DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerData(size:%d type:0x%08x stride:%d data:%p(%u) datalen:%u )", stream, var_size, var_type, var_stride, (void*)(inptr_data.get()), size_data, var_datalen);
3254 			this->glMatrixIndexPointerData(this, var_size, var_type, var_stride, (void*)(inptr_data.get()), var_datalen);
3255 			SET_LASTCALL("glMatrixIndexPointerData");
3256 			android::base::endTrace();
3257 			break;
3258 		}
3259 		case OP_glDrawElementsOffset: {
3260 			android::base::beginTrace("glDrawElementsOffset decode");
3261 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3262 			GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3263 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3264 			GLuint var_offset = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3265 			if (useChecksum) {
3266 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3267 					"gles1_decoder_context_t::decode, OP_glDrawElementsOffset: GL checksumCalculator failure\n");
3268 			}
3269 			#ifdef CHECK_GL_ERRORS
3270 			GLint err = this->glGetError();
3271 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsOffset\n", err);
3272 			#endif
3273 			DECODER_DEBUG_LOG("gles1(%p): glDrawElementsOffset(mode:0x%08x count:%d type:0x%08x offset:%u )", stream, var_mode, var_count, var_type, var_offset);
3274 			this->glDrawElementsOffset(this, var_mode, var_count, var_type, var_offset);
3275 			SET_LASTCALL("glDrawElementsOffset");
3276 			android::base::endTrace();
3277 			break;
3278 		}
3279 		case OP_glDrawElementsData: {
3280 			android::base::beginTrace("glDrawElementsData decode");
3281 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3282 			GLsizei var_count = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
3283 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3284 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
3285 			InputBuffer inptr_data(ptr + 8 + 4 + 4 + 4 + 4, size_data);
3286 			GLuint var_datalen = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + size_data);
3287 			if (useChecksum) {
3288 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_data + 4, ptr + 8 + 4 + 4 + 4 + 4 + size_data + 4, checksumSize,
3289 					"gles1_decoder_context_t::decode, OP_glDrawElementsData: GL checksumCalculator failure\n");
3290 			}
3291 			#ifdef CHECK_GL_ERRORS
3292 			GLint err = this->glGetError();
3293 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawElementsData\n", err);
3294 			#endif
3295 			DECODER_DEBUG_LOG("gles1(%p): glDrawElementsData(mode:0x%08x count:%d type:0x%08x data:%p(%u) datalen:%u )", stream, var_mode, var_count, var_type, (void*)(inptr_data.get()), size_data, var_datalen);
3296 			this->glDrawElementsData(this, var_mode, var_count, var_type, (void*)(inptr_data.get()), var_datalen);
3297 			SET_LASTCALL("glDrawElementsData");
3298 			android::base::endTrace();
3299 			break;
3300 		}
3301 		case OP_glGetCompressedTextureFormats: {
3302 			android::base::beginTrace("glGetCompressedTextureFormats decode");
3303 			int var_count = Unpack<int,uint32_t>(ptr + 8);
3304 			uint32_t size_formats __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3305 			if (useChecksum) {
3306 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3307 					"gles1_decoder_context_t::decode, OP_glGetCompressedTextureFormats: GL checksumCalculator failure\n");
3308 			}
3309 			size_t totalTmpSize = size_formats;
3310 			totalTmpSize += checksumSize;
3311 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3312 			OutputBuffer outptr_formats(&tmpBuf[0], size_formats);
3313 			#ifdef CHECK_GL_ERRORS
3314 			GLint err = this->glGetError();
3315 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetCompressedTextureFormats\n", err);
3316 			#endif
3317 			DECODER_DEBUG_LOG("gles1(%p): glGetCompressedTextureFormats(count:%d formats:%p(%u) )", stream, var_count, (GLint*)(outptr_formats.get()), size_formats);
3318 			this->glGetCompressedTextureFormats(this, var_count, (GLint*)(outptr_formats.get()));
3319 			outptr_formats.flush();
3320 			if (useChecksum) {
3321 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3322 			}
3323 			stream->flush();
3324 			SET_LASTCALL("glGetCompressedTextureFormats");
3325 			android::base::endTrace();
3326 			break;
3327 		}
3328 		case OP_glFinishRoundTrip: {
3329 			android::base::beginTrace("glFinishRoundTrip decode");
3330 			if (useChecksum) {
3331 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
3332 					"gles1_decoder_context_t::decode, OP_glFinishRoundTrip: GL checksumCalculator failure\n");
3333 			}
3334 			size_t totalTmpSize = sizeof(int);
3335 			totalTmpSize += checksumSize;
3336 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3337 			#ifdef CHECK_GL_ERRORS
3338 			GLint err = this->glGetError();
3339 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishRoundTrip\n", err);
3340 			#endif
3341 			DECODER_DEBUG_LOG("gles1(%p): glFinishRoundTrip()", stream);
3342 			*(int *)(&tmpBuf[0]) = 			this->glFinishRoundTrip(this);
3343 			if (useChecksum) {
3344 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3345 			}
3346 			stream->flush();
3347 			SET_LASTCALL("glFinishRoundTrip");
3348 			android::base::endTrace();
3349 			break;
3350 		}
3351 		case OP_glBlendEquationSeparateOES: {
3352 			android::base::beginTrace("glBlendEquationSeparateOES decode");
3353 			GLenum var_modeRGB = Unpack<GLenum,uint32_t>(ptr + 8);
3354 			GLenum var_modeAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3355 			if (useChecksum) {
3356 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3357 					"gles1_decoder_context_t::decode, OP_glBlendEquationSeparateOES: GL checksumCalculator failure\n");
3358 			}
3359 			#ifdef CHECK_GL_ERRORS
3360 			GLint err = this->glGetError();
3361 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationSeparateOES\n", err);
3362 			#endif
3363 			DECODER_DEBUG_LOG("gles1(%p): glBlendEquationSeparateOES(modeRGB:0x%08x modeAlpha:0x%08x )", stream, var_modeRGB, var_modeAlpha);
3364 			this->glBlendEquationSeparateOES(var_modeRGB, var_modeAlpha);
3365 			SET_LASTCALL("glBlendEquationSeparateOES");
3366 			android::base::endTrace();
3367 			break;
3368 		}
3369 		case OP_glBlendFuncSeparateOES: {
3370 			android::base::beginTrace("glBlendFuncSeparateOES decode");
3371 			GLenum var_srcRGB = Unpack<GLenum,uint32_t>(ptr + 8);
3372 			GLenum var_dstRGB = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3373 			GLenum var_srcAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
3374 			GLenum var_dstAlpha = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
3375 			if (useChecksum) {
3376 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3377 					"gles1_decoder_context_t::decode, OP_glBlendFuncSeparateOES: GL checksumCalculator failure\n");
3378 			}
3379 			#ifdef CHECK_GL_ERRORS
3380 			GLint err = this->glGetError();
3381 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendFuncSeparateOES\n", err);
3382 			#endif
3383 			DECODER_DEBUG_LOG("gles1(%p): glBlendFuncSeparateOES(srcRGB:0x%08x dstRGB:0x%08x srcAlpha:0x%08x dstAlpha:0x%08x )", stream, var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
3384 			this->glBlendFuncSeparateOES(var_srcRGB, var_dstRGB, var_srcAlpha, var_dstAlpha);
3385 			SET_LASTCALL("glBlendFuncSeparateOES");
3386 			android::base::endTrace();
3387 			break;
3388 		}
3389 		case OP_glBlendEquationOES: {
3390 			android::base::beginTrace("glBlendEquationOES decode");
3391 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
3392 			if (useChecksum) {
3393 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
3394 					"gles1_decoder_context_t::decode, OP_glBlendEquationOES: GL checksumCalculator failure\n");
3395 			}
3396 			#ifdef CHECK_GL_ERRORS
3397 			GLint err = this->glGetError();
3398 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBlendEquationOES\n", err);
3399 			#endif
3400 			DECODER_DEBUG_LOG("gles1(%p): glBlendEquationOES(mode:0x%08x )", stream, var_mode);
3401 			this->glBlendEquationOES(var_mode);
3402 			SET_LASTCALL("glBlendEquationOES");
3403 			android::base::endTrace();
3404 			break;
3405 		}
3406 		case OP_glDrawTexsOES: {
3407 			android::base::beginTrace("glDrawTexsOES decode");
3408 			GLshort var_x = Unpack<GLshort,uint16_t>(ptr + 8);
3409 			GLshort var_y = Unpack<GLshort,uint16_t>(ptr + 8 + 2);
3410 			GLshort var_z = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2);
3411 			GLshort var_width = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2);
3412 			GLshort var_height = Unpack<GLshort,uint16_t>(ptr + 8 + 2 + 2 + 2 + 2);
3413 			if (useChecksum) {
3414 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 2 + 2 + 2 + 2 + 2, ptr + 8 + 2 + 2 + 2 + 2 + 2, checksumSize,
3415 					"gles1_decoder_context_t::decode, OP_glDrawTexsOES: GL checksumCalculator failure\n");
3416 			}
3417 			#ifdef CHECK_GL_ERRORS
3418 			GLint err = this->glGetError();
3419 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsOES\n", err);
3420 			#endif
3421 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexsOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
3422 			this->glDrawTexsOES(var_x, var_y, var_z, var_width, var_height);
3423 			SET_LASTCALL("glDrawTexsOES");
3424 			android::base::endTrace();
3425 			break;
3426 		}
3427 		case OP_glDrawTexiOES: {
3428 			android::base::beginTrace("glDrawTexiOES decode");
3429 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
3430 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
3431 			GLint var_z = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
3432 			GLint var_width = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
3433 			GLint var_height = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3434 			if (useChecksum) {
3435 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3436 					"gles1_decoder_context_t::decode, OP_glDrawTexiOES: GL checksumCalculator failure\n");
3437 			}
3438 			#ifdef CHECK_GL_ERRORS
3439 			GLint err = this->glGetError();
3440 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexiOES\n", err);
3441 			#endif
3442 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexiOES(x:%d y:%d z:%d width:%d height:%d )", stream, var_x, var_y, var_z, var_width, var_height);
3443 			this->glDrawTexiOES(var_x, var_y, var_z, var_width, var_height);
3444 			SET_LASTCALL("glDrawTexiOES");
3445 			android::base::endTrace();
3446 			break;
3447 		}
3448 		case OP_glDrawTexxOES: {
3449 			android::base::beginTrace("glDrawTexxOES decode");
3450 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
3451 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3452 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3453 			GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3454 			GLfixed var_height = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3455 			if (useChecksum) {
3456 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3457 					"gles1_decoder_context_t::decode, OP_glDrawTexxOES: GL checksumCalculator failure\n");
3458 			}
3459 			#ifdef CHECK_GL_ERRORS
3460 			GLint err = this->glGetError();
3461 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxOES\n", err);
3462 			#endif
3463 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexxOES(x:0x%08x y:0x%08x z:0x%08x width:0x%08x height:0x%08x )", stream, var_x, var_y, var_z, var_width, var_height);
3464 			this->glDrawTexxOES(var_x, var_y, var_z, var_width, var_height);
3465 			SET_LASTCALL("glDrawTexxOES");
3466 			android::base::endTrace();
3467 			break;
3468 		}
3469 		case OP_glDrawTexsvOES: {
3470 			android::base::beginTrace("glDrawTexsvOES decode");
3471 			uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3472 			InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3473 			if (useChecksum) {
3474 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3475 					"gles1_decoder_context_t::decode, OP_glDrawTexsvOES: GL checksumCalculator failure\n");
3476 			}
3477 			#ifdef CHECK_GL_ERRORS
3478 			GLint err = this->glGetError();
3479 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexsvOES\n", err);
3480 			#endif
3481 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexsvOES(coords:%p(%u) )", stream, (const GLshort*)(inptr_coords.get()), size_coords);
3482 			this->glDrawTexsvOES((const GLshort*)(inptr_coords.get()));
3483 			SET_LASTCALL("glDrawTexsvOES");
3484 			android::base::endTrace();
3485 			break;
3486 		}
3487 		case OP_glDrawTexivOES: {
3488 			android::base::beginTrace("glDrawTexivOES decode");
3489 			uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3490 			InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3491 			if (useChecksum) {
3492 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3493 					"gles1_decoder_context_t::decode, OP_glDrawTexivOES: GL checksumCalculator failure\n");
3494 			}
3495 			#ifdef CHECK_GL_ERRORS
3496 			GLint err = this->glGetError();
3497 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexivOES\n", err);
3498 			#endif
3499 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexivOES(coords:%p(%u) )", stream, (const GLint*)(inptr_coords.get()), size_coords);
3500 			this->glDrawTexivOES((const GLint*)(inptr_coords.get()));
3501 			SET_LASTCALL("glDrawTexivOES");
3502 			android::base::endTrace();
3503 			break;
3504 		}
3505 		case OP_glDrawTexxvOES: {
3506 			android::base::beginTrace("glDrawTexxvOES decode");
3507 			uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3508 			InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3509 			if (useChecksum) {
3510 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3511 					"gles1_decoder_context_t::decode, OP_glDrawTexxvOES: GL checksumCalculator failure\n");
3512 			}
3513 			#ifdef CHECK_GL_ERRORS
3514 			GLint err = this->glGetError();
3515 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexxvOES\n", err);
3516 			#endif
3517 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexxvOES(coords:%p(%u) )", stream, (const GLfixed*)(inptr_coords.get()), size_coords);
3518 			this->glDrawTexxvOES((const GLfixed*)(inptr_coords.get()));
3519 			SET_LASTCALL("glDrawTexxvOES");
3520 			android::base::endTrace();
3521 			break;
3522 		}
3523 		case OP_glDrawTexfOES: {
3524 			android::base::beginTrace("glDrawTexfOES decode");
3525 			GLfloat var_x = Unpack<GLfloat,uint32_t>(ptr + 8);
3526 			GLfloat var_y = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
3527 			GLfloat var_z = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
3528 			GLfloat var_width = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
3529 			GLfloat var_height = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3530 			if (useChecksum) {
3531 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
3532 					"gles1_decoder_context_t::decode, OP_glDrawTexfOES: GL checksumCalculator failure\n");
3533 			}
3534 			#ifdef CHECK_GL_ERRORS
3535 			GLint err = this->glGetError();
3536 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfOES\n", err);
3537 			#endif
3538 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexfOES(x:%f y:%f z:%f width:%f height:%f )", stream, var_x, var_y, var_z, var_width, var_height);
3539 			this->glDrawTexfOES(var_x, var_y, var_z, var_width, var_height);
3540 			SET_LASTCALL("glDrawTexfOES");
3541 			android::base::endTrace();
3542 			break;
3543 		}
3544 		case OP_glDrawTexfvOES: {
3545 			android::base::beginTrace("glDrawTexfvOES decode");
3546 			uint32_t size_coords __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
3547 			InputBuffer inptr_coords(ptr + 8 + 4, size_coords);
3548 			if (useChecksum) {
3549 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_coords, ptr + 8 + 4 + size_coords, checksumSize,
3550 					"gles1_decoder_context_t::decode, OP_glDrawTexfvOES: GL checksumCalculator failure\n");
3551 			}
3552 			#ifdef CHECK_GL_ERRORS
3553 			GLint err = this->glGetError();
3554 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDrawTexfvOES\n", err);
3555 			#endif
3556 			DECODER_DEBUG_LOG("gles1(%p): glDrawTexfvOES(coords:%p(%u) )", stream, (const GLfloat*)(inptr_coords.get()), size_coords);
3557 			this->glDrawTexfvOES((const GLfloat*)(inptr_coords.get()));
3558 			SET_LASTCALL("glDrawTexfvOES");
3559 			android::base::endTrace();
3560 			break;
3561 		}
3562 		case OP_glEGLImageTargetTexture2DOES: {
3563 			android::base::beginTrace("glEGLImageTargetTexture2DOES decode");
3564 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3565 			GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
3566 			if (useChecksum) {
3567 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3568 					"gles1_decoder_context_t::decode, OP_glEGLImageTargetTexture2DOES: GL checksumCalculator failure\n");
3569 			}
3570 			#ifdef CHECK_GL_ERRORS
3571 			GLint err = this->glGetError();
3572 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetTexture2DOES\n", err);
3573 			#endif
3574 			DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetTexture2DOES(target:0x%08x image:%p )", stream, var_target, var_image);
3575 			this->glEGLImageTargetTexture2DOES(var_target, var_image);
3576 			SET_LASTCALL("glEGLImageTargetTexture2DOES");
3577 			android::base::endTrace();
3578 			break;
3579 		}
3580 		case OP_glEGLImageTargetRenderbufferStorageOES: {
3581 			android::base::beginTrace("glEGLImageTargetRenderbufferStorageOES decode");
3582 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3583 			GLeglImageOES var_image = Unpack<GLeglImageOES,uint32_t>(ptr + 8 + 4);
3584 			if (useChecksum) {
3585 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3586 					"gles1_decoder_context_t::decode, OP_glEGLImageTargetRenderbufferStorageOES: GL checksumCalculator failure\n");
3587 			}
3588 			#ifdef CHECK_GL_ERRORS
3589 			GLint err = this->glGetError();
3590 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEGLImageTargetRenderbufferStorageOES\n", err);
3591 			#endif
3592 			DECODER_DEBUG_LOG("gles1(%p): glEGLImageTargetRenderbufferStorageOES(target:0x%08x image:%p )", stream, var_target, var_image);
3593 			this->glEGLImageTargetRenderbufferStorageOES(var_target, var_image);
3594 			SET_LASTCALL("glEGLImageTargetRenderbufferStorageOES");
3595 			android::base::endTrace();
3596 			break;
3597 		}
3598 		case OP_glAlphaFuncxOES: {
3599 			android::base::beginTrace("glAlphaFuncxOES decode");
3600 			GLenum var_func = Unpack<GLenum,uint32_t>(ptr + 8);
3601 			GLclampx var_ref = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3602 			if (useChecksum) {
3603 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3604 					"gles1_decoder_context_t::decode, OP_glAlphaFuncxOES: GL checksumCalculator failure\n");
3605 			}
3606 			#ifdef CHECK_GL_ERRORS
3607 			GLint err = this->glGetError();
3608 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glAlphaFuncxOES\n", err);
3609 			#endif
3610 			DECODER_DEBUG_LOG("gles1(%p): glAlphaFuncxOES(func:0x%08x ref:0x%08x )", stream, var_func, var_ref);
3611 			this->glAlphaFuncxOES(var_func, var_ref);
3612 			SET_LASTCALL("glAlphaFuncxOES");
3613 			android::base::endTrace();
3614 			break;
3615 		}
3616 		case OP_glClearColorxOES: {
3617 			android::base::beginTrace("glClearColorxOES decode");
3618 			GLclampx var_red = Unpack<GLclampx,uint32_t>(ptr + 8);
3619 			GLclampx var_green = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3620 			GLclampx var_blue = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4);
3621 			GLclampx var_alpha = Unpack<GLclampx,uint32_t>(ptr + 8 + 4 + 4 + 4);
3622 			if (useChecksum) {
3623 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3624 					"gles1_decoder_context_t::decode, OP_glClearColorxOES: GL checksumCalculator failure\n");
3625 			}
3626 			#ifdef CHECK_GL_ERRORS
3627 			GLint err = this->glGetError();
3628 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearColorxOES\n", err);
3629 			#endif
3630 			DECODER_DEBUG_LOG("gles1(%p): glClearColorxOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
3631 			this->glClearColorxOES(var_red, var_green, var_blue, var_alpha);
3632 			SET_LASTCALL("glClearColorxOES");
3633 			android::base::endTrace();
3634 			break;
3635 		}
3636 		case OP_glClearDepthxOES: {
3637 			android::base::beginTrace("glClearDepthxOES decode");
3638 			GLclampx var_depth = Unpack<GLclampx,uint32_t>(ptr + 8);
3639 			if (useChecksum) {
3640 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
3641 					"gles1_decoder_context_t::decode, OP_glClearDepthxOES: GL checksumCalculator failure\n");
3642 			}
3643 			#ifdef CHECK_GL_ERRORS
3644 			GLint err = this->glGetError();
3645 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthxOES\n", err);
3646 			#endif
3647 			DECODER_DEBUG_LOG("gles1(%p): glClearDepthxOES(depth:0x%08x )", stream, var_depth);
3648 			this->glClearDepthxOES(var_depth);
3649 			SET_LASTCALL("glClearDepthxOES");
3650 			android::base::endTrace();
3651 			break;
3652 		}
3653 		case OP_glClipPlanexOES: {
3654 			android::base::beginTrace("glClipPlanexOES decode");
3655 			GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
3656 			uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3657 			InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
3658 			if (useChecksum) {
3659 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
3660 					"gles1_decoder_context_t::decode, OP_glClipPlanexOES: GL checksumCalculator failure\n");
3661 			}
3662 			#ifdef CHECK_GL_ERRORS
3663 			GLint err = this->glGetError();
3664 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexOES\n", err);
3665 			#endif
3666 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanexOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
3667 			this->glClipPlanexOES(var_plane, (const GLfixed*)(inptr_equation.get()));
3668 			SET_LASTCALL("glClipPlanexOES");
3669 			android::base::endTrace();
3670 			break;
3671 		}
3672 		case OP_glClipPlanexIMG: {
3673 			android::base::beginTrace("glClipPlanexIMG decode");
3674 			GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
3675 			uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3676 			InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
3677 			if (useChecksum) {
3678 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
3679 					"gles1_decoder_context_t::decode, OP_glClipPlanexIMG: GL checksumCalculator failure\n");
3680 			}
3681 			#ifdef CHECK_GL_ERRORS
3682 			GLint err = this->glGetError();
3683 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanexIMG\n", err);
3684 			#endif
3685 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanexIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfixed*)(inptr_equation.get()), size_equation);
3686 			this->glClipPlanexIMG(var_plane, (const GLfixed*)(inptr_equation.get()));
3687 			SET_LASTCALL("glClipPlanexIMG");
3688 			android::base::endTrace();
3689 			break;
3690 		}
3691 		case OP_glColor4xOES: {
3692 			android::base::beginTrace("glColor4xOES decode");
3693 			GLfixed var_red = Unpack<GLfixed,uint32_t>(ptr + 8);
3694 			GLfixed var_green = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3695 			GLfixed var_blue = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3696 			GLfixed var_alpha = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3697 			if (useChecksum) {
3698 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
3699 					"gles1_decoder_context_t::decode, OP_glColor4xOES: GL checksumCalculator failure\n");
3700 			}
3701 			#ifdef CHECK_GL_ERRORS
3702 			GLint err = this->glGetError();
3703 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glColor4xOES\n", err);
3704 			#endif
3705 			DECODER_DEBUG_LOG("gles1(%p): glColor4xOES(red:0x%08x green:0x%08x blue:0x%08x alpha:0x%08x )", stream, var_red, var_green, var_blue, var_alpha);
3706 			this->glColor4xOES(var_red, var_green, var_blue, var_alpha);
3707 			SET_LASTCALL("glColor4xOES");
3708 			android::base::endTrace();
3709 			break;
3710 		}
3711 		case OP_glDepthRangexOES: {
3712 			android::base::beginTrace("glDepthRangexOES decode");
3713 			GLclampx var_zNear = Unpack<GLclampx,uint32_t>(ptr + 8);
3714 			GLclampx var_zFar = Unpack<GLclampx,uint32_t>(ptr + 8 + 4);
3715 			if (useChecksum) {
3716 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3717 					"gles1_decoder_context_t::decode, OP_glDepthRangexOES: GL checksumCalculator failure\n");
3718 			}
3719 			#ifdef CHECK_GL_ERRORS
3720 			GLint err = this->glGetError();
3721 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangexOES\n", err);
3722 			#endif
3723 			DECODER_DEBUG_LOG("gles1(%p): glDepthRangexOES(zNear:0x%08x zFar:0x%08x )", stream, var_zNear, var_zFar);
3724 			this->glDepthRangexOES(var_zNear, var_zFar);
3725 			SET_LASTCALL("glDepthRangexOES");
3726 			android::base::endTrace();
3727 			break;
3728 		}
3729 		case OP_glFogxOES: {
3730 			android::base::beginTrace("glFogxOES decode");
3731 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3732 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3733 			if (useChecksum) {
3734 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3735 					"gles1_decoder_context_t::decode, OP_glFogxOES: GL checksumCalculator failure\n");
3736 			}
3737 			#ifdef CHECK_GL_ERRORS
3738 			GLint err = this->glGetError();
3739 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxOES\n", err);
3740 			#endif
3741 			DECODER_DEBUG_LOG("gles1(%p): glFogxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
3742 			this->glFogxOES(var_pname, var_param);
3743 			SET_LASTCALL("glFogxOES");
3744 			android::base::endTrace();
3745 			break;
3746 		}
3747 		case OP_glFogxvOES: {
3748 			android::base::beginTrace("glFogxvOES decode");
3749 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3750 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3751 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
3752 			if (useChecksum) {
3753 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
3754 					"gles1_decoder_context_t::decode, OP_glFogxvOES: GL checksumCalculator failure\n");
3755 			}
3756 			#ifdef CHECK_GL_ERRORS
3757 			GLint err = this->glGetError();
3758 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFogxvOES\n", err);
3759 			#endif
3760 			DECODER_DEBUG_LOG("gles1(%p): glFogxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
3761 			this->glFogxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
3762 			SET_LASTCALL("glFogxvOES");
3763 			android::base::endTrace();
3764 			break;
3765 		}
3766 		case OP_glFrustumxOES: {
3767 			android::base::beginTrace("glFrustumxOES decode");
3768 			GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
3769 			GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3770 			GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
3771 			GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
3772 			GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
3773 			GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
3774 			if (useChecksum) {
3775 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
3776 					"gles1_decoder_context_t::decode, OP_glFrustumxOES: GL checksumCalculator failure\n");
3777 			}
3778 			#ifdef CHECK_GL_ERRORS
3779 			GLint err = this->glGetError();
3780 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumxOES\n", err);
3781 			#endif
3782 			DECODER_DEBUG_LOG("gles1(%p): glFrustumxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
3783 			this->glFrustumxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
3784 			SET_LASTCALL("glFrustumxOES");
3785 			android::base::endTrace();
3786 			break;
3787 		}
3788 		case OP_glGetClipPlanexOES: {
3789 			android::base::beginTrace("glGetClipPlanexOES decode");
3790 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3791 			uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3792 			if (useChecksum) {
3793 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3794 					"gles1_decoder_context_t::decode, OP_glGetClipPlanexOES: GL checksumCalculator failure\n");
3795 			}
3796 			size_t totalTmpSize = size_eqn;
3797 			totalTmpSize += checksumSize;
3798 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3799 			OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
3800 			#ifdef CHECK_GL_ERRORS
3801 			GLint err = this->glGetError();
3802 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanexOES\n", err);
3803 			#endif
3804 			DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanexOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
3805 			this->glGetClipPlanexOES(var_pname, (GLfixed*)(outptr_eqn.get()));
3806 			outptr_eqn.flush();
3807 			if (useChecksum) {
3808 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3809 			}
3810 			stream->flush();
3811 			SET_LASTCALL("glGetClipPlanexOES");
3812 			android::base::endTrace();
3813 			break;
3814 		}
3815 		case OP_glGetClipPlanex: {
3816 			android::base::beginTrace("glGetClipPlanex decode");
3817 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3818 			uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3819 			if (useChecksum) {
3820 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3821 					"gles1_decoder_context_t::decode, OP_glGetClipPlanex: GL checksumCalculator failure\n");
3822 			}
3823 			size_t totalTmpSize = size_eqn;
3824 			totalTmpSize += checksumSize;
3825 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3826 			OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
3827 			#ifdef CHECK_GL_ERRORS
3828 			GLint err = this->glGetError();
3829 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanex\n", err);
3830 			#endif
3831 			DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanex(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_eqn.get()), size_eqn);
3832 			this->glGetClipPlanex(var_pname, (GLfixed*)(outptr_eqn.get()));
3833 			outptr_eqn.flush();
3834 			if (useChecksum) {
3835 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3836 			}
3837 			stream->flush();
3838 			SET_LASTCALL("glGetClipPlanex");
3839 			android::base::endTrace();
3840 			break;
3841 		}
3842 		case OP_glGetFixedvOES: {
3843 			android::base::beginTrace("glGetFixedvOES decode");
3844 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3845 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
3846 			if (useChecksum) {
3847 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3848 					"gles1_decoder_context_t::decode, OP_glGetFixedvOES: GL checksumCalculator failure\n");
3849 			}
3850 			size_t totalTmpSize = size_params;
3851 			totalTmpSize += checksumSize;
3852 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3853 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
3854 			#ifdef CHECK_GL_ERRORS
3855 			GLint err = this->glGetError();
3856 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFixedvOES\n", err);
3857 			#endif
3858 			DECODER_DEBUG_LOG("gles1(%p): glGetFixedvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3859 			this->glGetFixedvOES(var_pname, (GLfixed*)(outptr_params.get()));
3860 			outptr_params.flush();
3861 			if (useChecksum) {
3862 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3863 			}
3864 			stream->flush();
3865 			SET_LASTCALL("glGetFixedvOES");
3866 			android::base::endTrace();
3867 			break;
3868 		}
3869 		case OP_glGetLightxvOES: {
3870 			android::base::beginTrace("glGetLightxvOES decode");
3871 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
3872 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3873 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3874 			if (useChecksum) {
3875 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3876 					"gles1_decoder_context_t::decode, OP_glGetLightxvOES: GL checksumCalculator failure\n");
3877 			}
3878 			size_t totalTmpSize = size_params;
3879 			totalTmpSize += checksumSize;
3880 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3881 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
3882 			#ifdef CHECK_GL_ERRORS
3883 			GLint err = this->glGetError();
3884 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetLightxvOES\n", err);
3885 			#endif
3886 			DECODER_DEBUG_LOG("gles1(%p): glGetLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3887 			this->glGetLightxvOES(var_light, var_pname, (GLfixed*)(outptr_params.get()));
3888 			outptr_params.flush();
3889 			if (useChecksum) {
3890 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3891 			}
3892 			stream->flush();
3893 			SET_LASTCALL("glGetLightxvOES");
3894 			android::base::endTrace();
3895 			break;
3896 		}
3897 		case OP_glGetMaterialxvOES: {
3898 			android::base::beginTrace("glGetMaterialxvOES decode");
3899 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
3900 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3901 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3902 			if (useChecksum) {
3903 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3904 					"gles1_decoder_context_t::decode, OP_glGetMaterialxvOES: GL checksumCalculator failure\n");
3905 			}
3906 			size_t totalTmpSize = size_params;
3907 			totalTmpSize += checksumSize;
3908 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3909 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
3910 			#ifdef CHECK_GL_ERRORS
3911 			GLint err = this->glGetError();
3912 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetMaterialxvOES\n", err);
3913 			#endif
3914 			DECODER_DEBUG_LOG("gles1(%p): glGetMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3915 			this->glGetMaterialxvOES(var_face, var_pname, (GLfixed*)(outptr_params.get()));
3916 			outptr_params.flush();
3917 			if (useChecksum) {
3918 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3919 			}
3920 			stream->flush();
3921 			SET_LASTCALL("glGetMaterialxvOES");
3922 			android::base::endTrace();
3923 			break;
3924 		}
3925 		case OP_glGetTexEnvxvOES: {
3926 			android::base::beginTrace("glGetTexEnvxvOES decode");
3927 			GLenum var_env = Unpack<GLenum,uint32_t>(ptr + 8);
3928 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3929 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3930 			if (useChecksum) {
3931 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3932 					"gles1_decoder_context_t::decode, OP_glGetTexEnvxvOES: GL checksumCalculator failure\n");
3933 			}
3934 			size_t totalTmpSize = size_params;
3935 			totalTmpSize += checksumSize;
3936 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3937 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
3938 			#ifdef CHECK_GL_ERRORS
3939 			GLint err = this->glGetError();
3940 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexEnvxvOES\n", err);
3941 			#endif
3942 			DECODER_DEBUG_LOG("gles1(%p): glGetTexEnvxvOES(env:0x%08x pname:0x%08x params:%p(%u) )", stream, var_env, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3943 			this->glGetTexEnvxvOES(var_env, var_pname, (GLfixed*)(outptr_params.get()));
3944 			outptr_params.flush();
3945 			if (useChecksum) {
3946 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3947 			}
3948 			stream->flush();
3949 			SET_LASTCALL("glGetTexEnvxvOES");
3950 			android::base::endTrace();
3951 			break;
3952 		}
3953 		case OP_glGetTexParameterxvOES: {
3954 			android::base::beginTrace("glGetTexParameterxvOES decode");
3955 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
3956 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
3957 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
3958 			if (useChecksum) {
3959 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
3960 					"gles1_decoder_context_t::decode, OP_glGetTexParameterxvOES: GL checksumCalculator failure\n");
3961 			}
3962 			size_t totalTmpSize = size_params;
3963 			totalTmpSize += checksumSize;
3964 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
3965 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
3966 			#ifdef CHECK_GL_ERRORS
3967 			GLint err = this->glGetError();
3968 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexParameterxvOES\n", err);
3969 			#endif
3970 			DECODER_DEBUG_LOG("gles1(%p): glGetTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLfixed*)(outptr_params.get()), size_params);
3971 			this->glGetTexParameterxvOES(var_target, var_pname, (GLfixed*)(outptr_params.get()));
3972 			outptr_params.flush();
3973 			if (useChecksum) {
3974 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
3975 			}
3976 			stream->flush();
3977 			SET_LASTCALL("glGetTexParameterxvOES");
3978 			android::base::endTrace();
3979 			break;
3980 		}
3981 		case OP_glLightModelxOES: {
3982 			android::base::beginTrace("glLightModelxOES decode");
3983 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
3984 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
3985 			if (useChecksum) {
3986 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
3987 					"gles1_decoder_context_t::decode, OP_glLightModelxOES: GL checksumCalculator failure\n");
3988 			}
3989 			#ifdef CHECK_GL_ERRORS
3990 			GLint err = this->glGetError();
3991 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxOES\n", err);
3992 			#endif
3993 			DECODER_DEBUG_LOG("gles1(%p): glLightModelxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
3994 			this->glLightModelxOES(var_pname, var_param);
3995 			SET_LASTCALL("glLightModelxOES");
3996 			android::base::endTrace();
3997 			break;
3998 		}
3999 		case OP_glLightModelxvOES: {
4000 			android::base::beginTrace("glLightModelxvOES decode");
4001 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4002 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4003 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
4004 			if (useChecksum) {
4005 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
4006 					"gles1_decoder_context_t::decode, OP_glLightModelxvOES: GL checksumCalculator failure\n");
4007 			}
4008 			#ifdef CHECK_GL_ERRORS
4009 			GLint err = this->glGetError();
4010 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightModelxvOES\n", err);
4011 			#endif
4012 			DECODER_DEBUG_LOG("gles1(%p): glLightModelxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4013 			this->glLightModelxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
4014 			SET_LASTCALL("glLightModelxvOES");
4015 			android::base::endTrace();
4016 			break;
4017 		}
4018 		case OP_glLightxOES: {
4019 			android::base::beginTrace("glLightxOES decode");
4020 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
4021 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4022 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4023 			if (useChecksum) {
4024 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4025 					"gles1_decoder_context_t::decode, OP_glLightxOES: GL checksumCalculator failure\n");
4026 			}
4027 			#ifdef CHECK_GL_ERRORS
4028 			GLint err = this->glGetError();
4029 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxOES\n", err);
4030 			#endif
4031 			DECODER_DEBUG_LOG("gles1(%p): glLightxOES(light:0x%08x pname:0x%08x param:0x%08x )", stream, var_light, var_pname, var_param);
4032 			this->glLightxOES(var_light, var_pname, var_param);
4033 			SET_LASTCALL("glLightxOES");
4034 			android::base::endTrace();
4035 			break;
4036 		}
4037 		case OP_glLightxvOES: {
4038 			android::base::beginTrace("glLightxvOES decode");
4039 			GLenum var_light = Unpack<GLenum,uint32_t>(ptr + 8);
4040 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4041 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4042 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4043 			if (useChecksum) {
4044 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4045 					"gles1_decoder_context_t::decode, OP_glLightxvOES: GL checksumCalculator failure\n");
4046 			}
4047 			#ifdef CHECK_GL_ERRORS
4048 			GLint err = this->glGetError();
4049 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLightxvOES\n", err);
4050 			#endif
4051 			DECODER_DEBUG_LOG("gles1(%p): glLightxvOES(light:0x%08x pname:0x%08x params:%p(%u) )", stream, var_light, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4052 			this->glLightxvOES(var_light, var_pname, (const GLfixed*)(inptr_params.get()));
4053 			SET_LASTCALL("glLightxvOES");
4054 			android::base::endTrace();
4055 			break;
4056 		}
4057 		case OP_glLineWidthxOES: {
4058 			android::base::beginTrace("glLineWidthxOES decode");
4059 			GLfixed var_width = Unpack<GLfixed,uint32_t>(ptr + 8);
4060 			if (useChecksum) {
4061 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4062 					"gles1_decoder_context_t::decode, OP_glLineWidthxOES: GL checksumCalculator failure\n");
4063 			}
4064 			#ifdef CHECK_GL_ERRORS
4065 			GLint err = this->glGetError();
4066 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLineWidthxOES\n", err);
4067 			#endif
4068 			DECODER_DEBUG_LOG("gles1(%p): glLineWidthxOES(width:0x%08x )", stream, var_width);
4069 			this->glLineWidthxOES(var_width);
4070 			SET_LASTCALL("glLineWidthxOES");
4071 			android::base::endTrace();
4072 			break;
4073 		}
4074 		case OP_glLoadMatrixxOES: {
4075 			android::base::beginTrace("glLoadMatrixxOES decode");
4076 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4077 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
4078 			if (useChecksum) {
4079 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
4080 					"gles1_decoder_context_t::decode, OP_glLoadMatrixxOES: GL checksumCalculator failure\n");
4081 			}
4082 			#ifdef CHECK_GL_ERRORS
4083 			GLint err = this->glGetError();
4084 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadMatrixxOES\n", err);
4085 			#endif
4086 			DECODER_DEBUG_LOG("gles1(%p): glLoadMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
4087 			this->glLoadMatrixxOES((const GLfixed*)(inptr_m.get()));
4088 			SET_LASTCALL("glLoadMatrixxOES");
4089 			android::base::endTrace();
4090 			break;
4091 		}
4092 		case OP_glMaterialxOES: {
4093 			android::base::beginTrace("glMaterialxOES decode");
4094 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
4095 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4096 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4097 			if (useChecksum) {
4098 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4099 					"gles1_decoder_context_t::decode, OP_glMaterialxOES: GL checksumCalculator failure\n");
4100 			}
4101 			#ifdef CHECK_GL_ERRORS
4102 			GLint err = this->glGetError();
4103 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxOES\n", err);
4104 			#endif
4105 			DECODER_DEBUG_LOG("gles1(%p): glMaterialxOES(face:0x%08x pname:0x%08x param:0x%08x )", stream, var_face, var_pname, var_param);
4106 			this->glMaterialxOES(var_face, var_pname, var_param);
4107 			SET_LASTCALL("glMaterialxOES");
4108 			android::base::endTrace();
4109 			break;
4110 		}
4111 		case OP_glMaterialxvOES: {
4112 			android::base::beginTrace("glMaterialxvOES decode");
4113 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8);
4114 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4115 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4116 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4117 			if (useChecksum) {
4118 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4119 					"gles1_decoder_context_t::decode, OP_glMaterialxvOES: GL checksumCalculator failure\n");
4120 			}
4121 			#ifdef CHECK_GL_ERRORS
4122 			GLint err = this->glGetError();
4123 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMaterialxvOES\n", err);
4124 			#endif
4125 			DECODER_DEBUG_LOG("gles1(%p): glMaterialxvOES(face:0x%08x pname:0x%08x params:%p(%u) )", stream, var_face, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4126 			this->glMaterialxvOES(var_face, var_pname, (const GLfixed*)(inptr_params.get()));
4127 			SET_LASTCALL("glMaterialxvOES");
4128 			android::base::endTrace();
4129 			break;
4130 		}
4131 		case OP_glMultMatrixxOES: {
4132 			android::base::beginTrace("glMultMatrixxOES decode");
4133 			uint32_t size_m __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4134 			InputBuffer inptr_m(ptr + 8 + 4, size_m);
4135 			if (useChecksum) {
4136 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + size_m, ptr + 8 + 4 + size_m, checksumSize,
4137 					"gles1_decoder_context_t::decode, OP_glMultMatrixxOES: GL checksumCalculator failure\n");
4138 			}
4139 			#ifdef CHECK_GL_ERRORS
4140 			GLint err = this->glGetError();
4141 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultMatrixxOES\n", err);
4142 			#endif
4143 			DECODER_DEBUG_LOG("gles1(%p): glMultMatrixxOES(m:%p(%u) )", stream, (const GLfixed*)(inptr_m.get()), size_m);
4144 			this->glMultMatrixxOES((const GLfixed*)(inptr_m.get()));
4145 			SET_LASTCALL("glMultMatrixxOES");
4146 			android::base::endTrace();
4147 			break;
4148 		}
4149 		case OP_glMultiTexCoord4xOES: {
4150 			android::base::beginTrace("glMultiTexCoord4xOES decode");
4151 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4152 			GLfixed var_s = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4153 			GLfixed var_t = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4154 			GLfixed var_r = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4155 			GLfixed var_q = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4156 			if (useChecksum) {
4157 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
4158 					"gles1_decoder_context_t::decode, OP_glMultiTexCoord4xOES: GL checksumCalculator failure\n");
4159 			}
4160 			#ifdef CHECK_GL_ERRORS
4161 			GLint err = this->glGetError();
4162 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiTexCoord4xOES\n", err);
4163 			#endif
4164 			DECODER_DEBUG_LOG("gles1(%p): glMultiTexCoord4xOES(target:0x%08x s:0x%08x t:0x%08x r:0x%08x q:0x%08x )", stream, var_target, var_s, var_t, var_r, var_q);
4165 			this->glMultiTexCoord4xOES(var_target, var_s, var_t, var_r, var_q);
4166 			SET_LASTCALL("glMultiTexCoord4xOES");
4167 			android::base::endTrace();
4168 			break;
4169 		}
4170 		case OP_glNormal3xOES: {
4171 			android::base::beginTrace("glNormal3xOES decode");
4172 			GLfixed var_nx = Unpack<GLfixed,uint32_t>(ptr + 8);
4173 			GLfixed var_ny = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4174 			GLfixed var_nz = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4175 			if (useChecksum) {
4176 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4177 					"gles1_decoder_context_t::decode, OP_glNormal3xOES: GL checksumCalculator failure\n");
4178 			}
4179 			#ifdef CHECK_GL_ERRORS
4180 			GLint err = this->glGetError();
4181 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glNormal3xOES\n", err);
4182 			#endif
4183 			DECODER_DEBUG_LOG("gles1(%p): glNormal3xOES(nx:0x%08x ny:0x%08x nz:0x%08x )", stream, var_nx, var_ny, var_nz);
4184 			this->glNormal3xOES(var_nx, var_ny, var_nz);
4185 			SET_LASTCALL("glNormal3xOES");
4186 			android::base::endTrace();
4187 			break;
4188 		}
4189 		case OP_glOrthoxOES: {
4190 			android::base::beginTrace("glOrthoxOES decode");
4191 			GLfixed var_left = Unpack<GLfixed,uint32_t>(ptr + 8);
4192 			GLfixed var_right = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4193 			GLfixed var_bottom = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4194 			GLfixed var_top = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4195 			GLfixed var_zNear = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4196 			GLfixed var_zFar = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4197 			if (useChecksum) {
4198 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4199 					"gles1_decoder_context_t::decode, OP_glOrthoxOES: GL checksumCalculator failure\n");
4200 			}
4201 			#ifdef CHECK_GL_ERRORS
4202 			GLint err = this->glGetError();
4203 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthoxOES\n", err);
4204 			#endif
4205 			DECODER_DEBUG_LOG("gles1(%p): glOrthoxOES(left:0x%08x right:0x%08x bottom:0x%08x top:0x%08x zNear:0x%08x zFar:0x%08x )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4206 			this->glOrthoxOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4207 			SET_LASTCALL("glOrthoxOES");
4208 			android::base::endTrace();
4209 			break;
4210 		}
4211 		case OP_glPointParameterxOES: {
4212 			android::base::beginTrace("glPointParameterxOES decode");
4213 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4214 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4215 			if (useChecksum) {
4216 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4217 					"gles1_decoder_context_t::decode, OP_glPointParameterxOES: GL checksumCalculator failure\n");
4218 			}
4219 			#ifdef CHECK_GL_ERRORS
4220 			GLint err = this->glGetError();
4221 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxOES\n", err);
4222 			#endif
4223 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterxOES(pname:0x%08x param:0x%08x )", stream, var_pname, var_param);
4224 			this->glPointParameterxOES(var_pname, var_param);
4225 			SET_LASTCALL("glPointParameterxOES");
4226 			android::base::endTrace();
4227 			break;
4228 		}
4229 		case OP_glPointParameterxvOES: {
4230 			android::base::beginTrace("glPointParameterxvOES decode");
4231 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
4232 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4233 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
4234 			if (useChecksum) {
4235 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
4236 					"gles1_decoder_context_t::decode, OP_glPointParameterxvOES: GL checksumCalculator failure\n");
4237 			}
4238 			#ifdef CHECK_GL_ERRORS
4239 			GLint err = this->glGetError();
4240 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointParameterxvOES\n", err);
4241 			#endif
4242 			DECODER_DEBUG_LOG("gles1(%p): glPointParameterxvOES(pname:0x%08x params:%p(%u) )", stream, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4243 			this->glPointParameterxvOES(var_pname, (const GLfixed*)(inptr_params.get()));
4244 			SET_LASTCALL("glPointParameterxvOES");
4245 			android::base::endTrace();
4246 			break;
4247 		}
4248 		case OP_glPointSizexOES: {
4249 			android::base::beginTrace("glPointSizexOES decode");
4250 			GLfixed var_size = Unpack<GLfixed,uint32_t>(ptr + 8);
4251 			if (useChecksum) {
4252 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4253 					"gles1_decoder_context_t::decode, OP_glPointSizexOES: GL checksumCalculator failure\n");
4254 			}
4255 			#ifdef CHECK_GL_ERRORS
4256 			GLint err = this->glGetError();
4257 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPointSizexOES\n", err);
4258 			#endif
4259 			DECODER_DEBUG_LOG("gles1(%p): glPointSizexOES(size:0x%08x )", stream, var_size);
4260 			this->glPointSizexOES(var_size);
4261 			SET_LASTCALL("glPointSizexOES");
4262 			android::base::endTrace();
4263 			break;
4264 		}
4265 		case OP_glPolygonOffsetxOES: {
4266 			android::base::beginTrace("glPolygonOffsetxOES decode");
4267 			GLfixed var_factor = Unpack<GLfixed,uint32_t>(ptr + 8);
4268 			GLfixed var_units = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4269 			if (useChecksum) {
4270 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4271 					"gles1_decoder_context_t::decode, OP_glPolygonOffsetxOES: GL checksumCalculator failure\n");
4272 			}
4273 			#ifdef CHECK_GL_ERRORS
4274 			GLint err = this->glGetError();
4275 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glPolygonOffsetxOES\n", err);
4276 			#endif
4277 			DECODER_DEBUG_LOG("gles1(%p): glPolygonOffsetxOES(factor:0x%08x units:0x%08x )", stream, var_factor, var_units);
4278 			this->glPolygonOffsetxOES(var_factor, var_units);
4279 			SET_LASTCALL("glPolygonOffsetxOES");
4280 			android::base::endTrace();
4281 			break;
4282 		}
4283 		case OP_glRotatexOES: {
4284 			android::base::beginTrace("glRotatexOES decode");
4285 			GLfixed var_angle = Unpack<GLfixed,uint32_t>(ptr + 8);
4286 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4287 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4288 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4 + 4);
4289 			if (useChecksum) {
4290 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4291 					"gles1_decoder_context_t::decode, OP_glRotatexOES: GL checksumCalculator failure\n");
4292 			}
4293 			#ifdef CHECK_GL_ERRORS
4294 			GLint err = this->glGetError();
4295 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRotatexOES\n", err);
4296 			#endif
4297 			DECODER_DEBUG_LOG("gles1(%p): glRotatexOES(angle:0x%08x x:0x%08x y:0x%08x z:0x%08x )", stream, var_angle, var_x, var_y, var_z);
4298 			this->glRotatexOES(var_angle, var_x, var_y, var_z);
4299 			SET_LASTCALL("glRotatexOES");
4300 			android::base::endTrace();
4301 			break;
4302 		}
4303 		case OP_glSampleCoveragexOES: {
4304 			android::base::beginTrace("glSampleCoveragexOES decode");
4305 			GLclampx var_value = Unpack<GLclampx,uint32_t>(ptr + 8);
4306 			GLboolean var_invert = Unpack<GLboolean,uint8_t>(ptr + 8 + 4);
4307 			if (useChecksum) {
4308 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 1, ptr + 8 + 4 + 1, checksumSize,
4309 					"gles1_decoder_context_t::decode, OP_glSampleCoveragexOES: GL checksumCalculator failure\n");
4310 			}
4311 			#ifdef CHECK_GL_ERRORS
4312 			GLint err = this->glGetError();
4313 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSampleCoveragexOES\n", err);
4314 			#endif
4315 			DECODER_DEBUG_LOG("gles1(%p): glSampleCoveragexOES(value:0x%08x invert:%d )", stream, var_value, var_invert);
4316 			this->glSampleCoveragexOES(var_value, var_invert);
4317 			SET_LASTCALL("glSampleCoveragexOES");
4318 			android::base::endTrace();
4319 			break;
4320 		}
4321 		case OP_glScalexOES: {
4322 			android::base::beginTrace("glScalexOES decode");
4323 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
4324 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4325 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4326 			if (useChecksum) {
4327 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4328 					"gles1_decoder_context_t::decode, OP_glScalexOES: GL checksumCalculator failure\n");
4329 			}
4330 			#ifdef CHECK_GL_ERRORS
4331 			GLint err = this->glGetError();
4332 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glScalexOES\n", err);
4333 			#endif
4334 			DECODER_DEBUG_LOG("gles1(%p): glScalexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
4335 			this->glScalexOES(var_x, var_y, var_z);
4336 			SET_LASTCALL("glScalexOES");
4337 			android::base::endTrace();
4338 			break;
4339 		}
4340 		case OP_glTexEnvxOES: {
4341 			android::base::beginTrace("glTexEnvxOES decode");
4342 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4343 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4344 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4345 			if (useChecksum) {
4346 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4347 					"gles1_decoder_context_t::decode, OP_glTexEnvxOES: GL checksumCalculator failure\n");
4348 			}
4349 			#ifdef CHECK_GL_ERRORS
4350 			GLint err = this->glGetError();
4351 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxOES\n", err);
4352 			#endif
4353 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
4354 			this->glTexEnvxOES(var_target, var_pname, var_param);
4355 			SET_LASTCALL("glTexEnvxOES");
4356 			android::base::endTrace();
4357 			break;
4358 		}
4359 		case OP_glTexEnvxvOES: {
4360 			android::base::beginTrace("glTexEnvxvOES decode");
4361 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4362 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4363 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4364 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4365 			if (useChecksum) {
4366 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4367 					"gles1_decoder_context_t::decode, OP_glTexEnvxvOES: GL checksumCalculator failure\n");
4368 			}
4369 			#ifdef CHECK_GL_ERRORS
4370 			GLint err = this->glGetError();
4371 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexEnvxvOES\n", err);
4372 			#endif
4373 			DECODER_DEBUG_LOG("gles1(%p): glTexEnvxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4374 			this->glTexEnvxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
4375 			SET_LASTCALL("glTexEnvxvOES");
4376 			android::base::endTrace();
4377 			break;
4378 		}
4379 		case OP_glTexParameterxOES: {
4380 			android::base::beginTrace("glTexParameterxOES decode");
4381 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4382 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4383 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4384 			if (useChecksum) {
4385 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4386 					"gles1_decoder_context_t::decode, OP_glTexParameterxOES: GL checksumCalculator failure\n");
4387 			}
4388 			#ifdef CHECK_GL_ERRORS
4389 			GLint err = this->glGetError();
4390 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxOES\n", err);
4391 			#endif
4392 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterxOES(target:0x%08x pname:0x%08x param:0x%08x )", stream, var_target, var_pname, var_param);
4393 			this->glTexParameterxOES(var_target, var_pname, var_param);
4394 			SET_LASTCALL("glTexParameterxOES");
4395 			android::base::endTrace();
4396 			break;
4397 		}
4398 		case OP_glTexParameterxvOES: {
4399 			android::base::beginTrace("glTexParameterxvOES decode");
4400 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4401 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4402 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4403 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4404 			if (useChecksum) {
4405 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4406 					"gles1_decoder_context_t::decode, OP_glTexParameterxvOES: GL checksumCalculator failure\n");
4407 			}
4408 			#ifdef CHECK_GL_ERRORS
4409 			GLint err = this->glGetError();
4410 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexParameterxvOES\n", err);
4411 			#endif
4412 			DECODER_DEBUG_LOG("gles1(%p): glTexParameterxvOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
4413 			this->glTexParameterxvOES(var_target, var_pname, (const GLfixed*)(inptr_params.get()));
4414 			SET_LASTCALL("glTexParameterxvOES");
4415 			android::base::endTrace();
4416 			break;
4417 		}
4418 		case OP_glTranslatexOES: {
4419 			android::base::beginTrace("glTranslatexOES decode");
4420 			GLfixed var_x = Unpack<GLfixed,uint32_t>(ptr + 8);
4421 			GLfixed var_y = Unpack<GLfixed,uint32_t>(ptr + 8 + 4);
4422 			GLfixed var_z = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
4423 			if (useChecksum) {
4424 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4425 					"gles1_decoder_context_t::decode, OP_glTranslatexOES: GL checksumCalculator failure\n");
4426 			}
4427 			#ifdef CHECK_GL_ERRORS
4428 			GLint err = this->glGetError();
4429 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTranslatexOES\n", err);
4430 			#endif
4431 			DECODER_DEBUG_LOG("gles1(%p): glTranslatexOES(x:0x%08x y:0x%08x z:0x%08x )", stream, var_x, var_y, var_z);
4432 			this->glTranslatexOES(var_x, var_y, var_z);
4433 			SET_LASTCALL("glTranslatexOES");
4434 			android::base::endTrace();
4435 			break;
4436 		}
4437 		case OP_glIsRenderbufferOES: {
4438 			android::base::beginTrace("glIsRenderbufferOES decode");
4439 			GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8);
4440 			if (useChecksum) {
4441 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4442 					"gles1_decoder_context_t::decode, OP_glIsRenderbufferOES: GL checksumCalculator failure\n");
4443 			}
4444 			size_t totalTmpSize = sizeof(GLboolean);
4445 			totalTmpSize += checksumSize;
4446 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4447 			#ifdef CHECK_GL_ERRORS
4448 			GLint err = this->glGetError();
4449 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsRenderbufferOES\n", err);
4450 			#endif
4451 			DECODER_DEBUG_LOG("gles1(%p): glIsRenderbufferOES(renderbuffer:%u )", stream, var_renderbuffer);
4452 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsRenderbufferOES(var_renderbuffer);
4453 			if (useChecksum) {
4454 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4455 			}
4456 			stream->flush();
4457 			SET_LASTCALL("glIsRenderbufferOES");
4458 			android::base::endTrace();
4459 			break;
4460 		}
4461 		case OP_glBindRenderbufferOES: {
4462 			android::base::beginTrace("glBindRenderbufferOES decode");
4463 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4464 			GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
4465 			if (useChecksum) {
4466 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4467 					"gles1_decoder_context_t::decode, OP_glBindRenderbufferOES: GL checksumCalculator failure\n");
4468 			}
4469 			#ifdef CHECK_GL_ERRORS
4470 			GLint err = this->glGetError();
4471 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindRenderbufferOES\n", err);
4472 			#endif
4473 			DECODER_DEBUG_LOG("gles1(%p): glBindRenderbufferOES(target:0x%08x renderbuffer:%u )", stream, var_target, var_renderbuffer);
4474 			this->glBindRenderbufferOES(var_target, var_renderbuffer);
4475 			SET_LASTCALL("glBindRenderbufferOES");
4476 			android::base::endTrace();
4477 			break;
4478 		}
4479 		case OP_glDeleteRenderbuffersOES: {
4480 			android::base::beginTrace("glDeleteRenderbuffersOES decode");
4481 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4482 			uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4483 			InputBuffer inptr_renderbuffers(ptr + 8 + 4 + 4, size_renderbuffers);
4484 			if (useChecksum) {
4485 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_renderbuffers, ptr + 8 + 4 + 4 + size_renderbuffers, checksumSize,
4486 					"gles1_decoder_context_t::decode, OP_glDeleteRenderbuffersOES: GL checksumCalculator failure\n");
4487 			}
4488 			#ifdef CHECK_GL_ERRORS
4489 			GLint err = this->glGetError();
4490 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteRenderbuffersOES\n", err);
4491 			#endif
4492 			DECODER_DEBUG_LOG("gles1(%p): glDeleteRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_renderbuffers.get()), size_renderbuffers);
4493 			this->glDeleteRenderbuffersOES_dec(this, var_n, (const GLuint*)(inptr_renderbuffers.get()));
4494 			SET_LASTCALL("glDeleteRenderbuffersOES");
4495 			android::base::endTrace();
4496 			break;
4497 		}
4498 		case OP_glGenRenderbuffersOES: {
4499 			android::base::beginTrace("glGenRenderbuffersOES decode");
4500 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4501 			uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4502 			if (useChecksum) {
4503 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4504 					"gles1_decoder_context_t::decode, OP_glGenRenderbuffersOES: GL checksumCalculator failure\n");
4505 			}
4506 			size_t totalTmpSize = size_renderbuffers;
4507 			totalTmpSize += checksumSize;
4508 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4509 			OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
4510 			#ifdef CHECK_GL_ERRORS
4511 			GLint err = this->glGetError();
4512 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenRenderbuffersOES\n", err);
4513 			#endif
4514 			DECODER_DEBUG_LOG("gles1(%p): glGenRenderbuffersOES(n:%d renderbuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers);
4515 			this->glGenRenderbuffersOES_dec(this, var_n, (GLuint*)(outptr_renderbuffers.get()));
4516 			outptr_renderbuffers.flush();
4517 			if (useChecksum) {
4518 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4519 			}
4520 			stream->flush();
4521 			SET_LASTCALL("glGenRenderbuffersOES");
4522 			android::base::endTrace();
4523 			break;
4524 		}
4525 		case OP_glRenderbufferStorageOES: {
4526 			android::base::beginTrace("glRenderbufferStorageOES decode");
4527 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4528 			GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4529 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4530 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
4531 			if (useChecksum) {
4532 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4533 					"gles1_decoder_context_t::decode, OP_glRenderbufferStorageOES: GL checksumCalculator failure\n");
4534 			}
4535 			#ifdef CHECK_GL_ERRORS
4536 			GLint err = this->glGetError();
4537 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageOES\n", err);
4538 			#endif
4539 			DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageOES(target:0x%08x internalformat:0x%08x width:%d height:%d )", stream, var_target, var_internalformat, var_width, var_height);
4540 			this->glRenderbufferStorageOES(var_target, var_internalformat, var_width, var_height);
4541 			SET_LASTCALL("glRenderbufferStorageOES");
4542 			android::base::endTrace();
4543 			break;
4544 		}
4545 		case OP_glGetRenderbufferParameterivOES: {
4546 			android::base::beginTrace("glGetRenderbufferParameterivOES decode");
4547 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4548 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4549 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4550 			if (useChecksum) {
4551 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
4552 					"gles1_decoder_context_t::decode, OP_glGetRenderbufferParameterivOES: GL checksumCalculator failure\n");
4553 			}
4554 			size_t totalTmpSize = size_params;
4555 			totalTmpSize += checksumSize;
4556 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4557 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
4558 			#ifdef CHECK_GL_ERRORS
4559 			GLint err = this->glGetError();
4560 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetRenderbufferParameterivOES\n", err);
4561 			#endif
4562 			DECODER_DEBUG_LOG("gles1(%p): glGetRenderbufferParameterivOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLint*)(outptr_params.get()), size_params);
4563 			this->glGetRenderbufferParameterivOES(var_target, var_pname, (GLint*)(outptr_params.get()));
4564 			outptr_params.flush();
4565 			if (useChecksum) {
4566 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4567 			}
4568 			stream->flush();
4569 			SET_LASTCALL("glGetRenderbufferParameterivOES");
4570 			android::base::endTrace();
4571 			break;
4572 		}
4573 		case OP_glIsFramebufferOES: {
4574 			android::base::beginTrace("glIsFramebufferOES decode");
4575 			GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8);
4576 			if (useChecksum) {
4577 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4578 					"gles1_decoder_context_t::decode, OP_glIsFramebufferOES: GL checksumCalculator failure\n");
4579 			}
4580 			size_t totalTmpSize = sizeof(GLboolean);
4581 			totalTmpSize += checksumSize;
4582 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4583 			#ifdef CHECK_GL_ERRORS
4584 			GLint err = this->glGetError();
4585 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFramebufferOES\n", err);
4586 			#endif
4587 			DECODER_DEBUG_LOG("gles1(%p): glIsFramebufferOES(framebuffer:%u )", stream, var_framebuffer);
4588 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsFramebufferOES(var_framebuffer);
4589 			if (useChecksum) {
4590 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4591 			}
4592 			stream->flush();
4593 			SET_LASTCALL("glIsFramebufferOES");
4594 			android::base::endTrace();
4595 			break;
4596 		}
4597 		case OP_glBindFramebufferOES: {
4598 			android::base::beginTrace("glBindFramebufferOES decode");
4599 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4600 			GLuint var_framebuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
4601 			if (useChecksum) {
4602 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4603 					"gles1_decoder_context_t::decode, OP_glBindFramebufferOES: GL checksumCalculator failure\n");
4604 			}
4605 			#ifdef CHECK_GL_ERRORS
4606 			GLint err = this->glGetError();
4607 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindFramebufferOES\n", err);
4608 			#endif
4609 			DECODER_DEBUG_LOG("gles1(%p): glBindFramebufferOES(target:0x%08x framebuffer:%u )", stream, var_target, var_framebuffer);
4610 			this->glBindFramebufferOES(var_target, var_framebuffer);
4611 			SET_LASTCALL("glBindFramebufferOES");
4612 			android::base::endTrace();
4613 			break;
4614 		}
4615 		case OP_glDeleteFramebuffersOES: {
4616 			android::base::beginTrace("glDeleteFramebuffersOES decode");
4617 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4618 			uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4619 			InputBuffer inptr_framebuffers(ptr + 8 + 4 + 4, size_framebuffers);
4620 			if (useChecksum) {
4621 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_framebuffers, ptr + 8 + 4 + 4 + size_framebuffers, checksumSize,
4622 					"gles1_decoder_context_t::decode, OP_glDeleteFramebuffersOES: GL checksumCalculator failure\n");
4623 			}
4624 			#ifdef CHECK_GL_ERRORS
4625 			GLint err = this->glGetError();
4626 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFramebuffersOES\n", err);
4627 			#endif
4628 			DECODER_DEBUG_LOG("gles1(%p): glDeleteFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (const GLuint*)(inptr_framebuffers.get()), size_framebuffers);
4629 			this->glDeleteFramebuffersOES_dec(this, var_n, (const GLuint*)(inptr_framebuffers.get()));
4630 			SET_LASTCALL("glDeleteFramebuffersOES");
4631 			android::base::endTrace();
4632 			break;
4633 		}
4634 		case OP_glGenFramebuffersOES: {
4635 			android::base::beginTrace("glGenFramebuffersOES decode");
4636 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
4637 			uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4638 			if (useChecksum) {
4639 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4640 					"gles1_decoder_context_t::decode, OP_glGenFramebuffersOES: GL checksumCalculator failure\n");
4641 			}
4642 			size_t totalTmpSize = size_framebuffers;
4643 			totalTmpSize += checksumSize;
4644 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4645 			OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
4646 			#ifdef CHECK_GL_ERRORS
4647 			GLint err = this->glGetError();
4648 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFramebuffersOES\n", err);
4649 			#endif
4650 			DECODER_DEBUG_LOG("gles1(%p): glGenFramebuffersOES(n:%d framebuffers:%p(%u) )", stream, var_n, (GLuint*)(outptr_framebuffers.get()), size_framebuffers);
4651 			this->glGenFramebuffersOES_dec(this, var_n, (GLuint*)(outptr_framebuffers.get()));
4652 			outptr_framebuffers.flush();
4653 			if (useChecksum) {
4654 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4655 			}
4656 			stream->flush();
4657 			SET_LASTCALL("glGenFramebuffersOES");
4658 			android::base::endTrace();
4659 			break;
4660 		}
4661 		case OP_glCheckFramebufferStatusOES: {
4662 			android::base::beginTrace("glCheckFramebufferStatusOES decode");
4663 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4664 			if (useChecksum) {
4665 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4666 					"gles1_decoder_context_t::decode, OP_glCheckFramebufferStatusOES: GL checksumCalculator failure\n");
4667 			}
4668 			size_t totalTmpSize = sizeof(GLenum);
4669 			totalTmpSize += checksumSize;
4670 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4671 			#ifdef CHECK_GL_ERRORS
4672 			GLint err = this->glGetError();
4673 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCheckFramebufferStatusOES\n", err);
4674 			#endif
4675 			DECODER_DEBUG_LOG("gles1(%p): glCheckFramebufferStatusOES(target:0x%08x )", stream, var_target);
4676 			*(GLenum *)(&tmpBuf[0]) = 			this->glCheckFramebufferStatusOES(var_target);
4677 			if (useChecksum) {
4678 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4679 			}
4680 			stream->flush();
4681 			SET_LASTCALL("glCheckFramebufferStatusOES");
4682 			android::base::endTrace();
4683 			break;
4684 		}
4685 		case OP_glFramebufferRenderbufferOES: {
4686 			android::base::beginTrace("glFramebufferRenderbufferOES decode");
4687 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4688 			GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4689 			GLenum var_renderbuffertarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4690 			GLuint var_renderbuffer = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
4691 			if (useChecksum) {
4692 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4693 					"gles1_decoder_context_t::decode, OP_glFramebufferRenderbufferOES: GL checksumCalculator failure\n");
4694 			}
4695 			#ifdef CHECK_GL_ERRORS
4696 			GLint err = this->glGetError();
4697 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferRenderbufferOES\n", err);
4698 			#endif
4699 			DECODER_DEBUG_LOG("gles1(%p): glFramebufferRenderbufferOES(target:0x%08x attachment:0x%08x renderbuffertarget:0x%08x renderbuffer:%u )", stream, var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
4700 			this->glFramebufferRenderbufferOES(var_target, var_attachment, var_renderbuffertarget, var_renderbuffer);
4701 			SET_LASTCALL("glFramebufferRenderbufferOES");
4702 			android::base::endTrace();
4703 			break;
4704 		}
4705 		case OP_glFramebufferTexture2DOES: {
4706 			android::base::beginTrace("glFramebufferTexture2DOES decode");
4707 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4708 			GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4709 			GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4710 			GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
4711 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4712 			if (useChecksum) {
4713 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
4714 					"gles1_decoder_context_t::decode, OP_glFramebufferTexture2DOES: GL checksumCalculator failure\n");
4715 			}
4716 			#ifdef CHECK_GL_ERRORS
4717 			GLint err = this->glGetError();
4718 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DOES\n", err);
4719 			#endif
4720 			DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DOES(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level);
4721 			this->glFramebufferTexture2DOES(var_target, var_attachment, var_textarget, var_texture, var_level);
4722 			SET_LASTCALL("glFramebufferTexture2DOES");
4723 			android::base::endTrace();
4724 			break;
4725 		}
4726 		case OP_glGetFramebufferAttachmentParameterivOES: {
4727 			android::base::beginTrace("glGetFramebufferAttachmentParameterivOES decode");
4728 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4729 			GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4730 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
4731 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4732 			if (useChecksum) {
4733 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
4734 					"gles1_decoder_context_t::decode, OP_glGetFramebufferAttachmentParameterivOES: GL checksumCalculator failure\n");
4735 			}
4736 			size_t totalTmpSize = size_params;
4737 			totalTmpSize += checksumSize;
4738 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4739 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
4740 			#ifdef CHECK_GL_ERRORS
4741 			GLint err = this->glGetError();
4742 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFramebufferAttachmentParameterivOES\n", err);
4743 			#endif
4744 			DECODER_DEBUG_LOG("gles1(%p): glGetFramebufferAttachmentParameterivOES(target:0x%08x attachment:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()), size_params);
4745 			this->glGetFramebufferAttachmentParameterivOES(var_target, var_attachment, var_pname, (GLint*)(outptr_params.get()));
4746 			outptr_params.flush();
4747 			if (useChecksum) {
4748 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4749 			}
4750 			stream->flush();
4751 			SET_LASTCALL("glGetFramebufferAttachmentParameterivOES");
4752 			android::base::endTrace();
4753 			break;
4754 		}
4755 		case OP_glGenerateMipmapOES: {
4756 			android::base::beginTrace("glGenerateMipmapOES decode");
4757 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4758 			if (useChecksum) {
4759 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4760 					"gles1_decoder_context_t::decode, OP_glGenerateMipmapOES: GL checksumCalculator failure\n");
4761 			}
4762 			#ifdef CHECK_GL_ERRORS
4763 			GLint err = this->glGetError();
4764 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenerateMipmapOES\n", err);
4765 			#endif
4766 			DECODER_DEBUG_LOG("gles1(%p): glGenerateMipmapOES(target:0x%08x )", stream, var_target);
4767 			this->glGenerateMipmapOES(var_target);
4768 			SET_LASTCALL("glGenerateMipmapOES");
4769 			android::base::endTrace();
4770 			break;
4771 		}
4772 		case OP_glMapBufferOES: {
4773 			android::base::beginTrace("glMapBufferOES decode");
4774 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4775 			GLenum var_access = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4776 			if (useChecksum) {
4777 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4778 					"gles1_decoder_context_t::decode, OP_glMapBufferOES: GL checksumCalculator failure\n");
4779 			}
4780 			#ifdef CHECK_GL_ERRORS
4781 			GLint err = this->glGetError();
4782 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMapBufferOES\n", err);
4783 			#endif
4784 			DECODER_DEBUG_LOG("gles1(%p): glMapBufferOES(target:0x%08x access:0x%08x )", stream, var_target, var_access);
4785 			this->glMapBufferOES(var_target, var_access);
4786 			SET_LASTCALL("glMapBufferOES");
4787 			android::base::endTrace();
4788 			break;
4789 		}
4790 		case OP_glUnmapBufferOES: {
4791 			android::base::beginTrace("glUnmapBufferOES decode");
4792 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4793 			if (useChecksum) {
4794 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4795 					"gles1_decoder_context_t::decode, OP_glUnmapBufferOES: GL checksumCalculator failure\n");
4796 			}
4797 			size_t totalTmpSize = sizeof(GLboolean);
4798 			totalTmpSize += checksumSize;
4799 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4800 			#ifdef CHECK_GL_ERRORS
4801 			GLint err = this->glGetError();
4802 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glUnmapBufferOES\n", err);
4803 			#endif
4804 			DECODER_DEBUG_LOG("gles1(%p): glUnmapBufferOES(target:0x%08x )", stream, var_target);
4805 			*(GLboolean *)(&tmpBuf[0]) = 			this->glUnmapBufferOES(var_target);
4806 			if (useChecksum) {
4807 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4808 			}
4809 			stream->flush();
4810 			SET_LASTCALL("glUnmapBufferOES");
4811 			android::base::endTrace();
4812 			break;
4813 		}
4814 		case OP_glGetBufferPointervOES: {
4815 			android::base::beginTrace("glGetBufferPointervOES decode");
4816 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
4817 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4818 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
4819 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
4820 			if (useChecksum) {
4821 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
4822 					"gles1_decoder_context_t::decode, OP_glGetBufferPointervOES: GL checksumCalculator failure\n");
4823 			}
4824 			#ifdef CHECK_GL_ERRORS
4825 			GLint err = this->glGetError();
4826 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetBufferPointervOES\n", err);
4827 			#endif
4828 			DECODER_DEBUG_LOG("gles1(%p): glGetBufferPointervOES(target:0x%08x pname:0x%08x params:%p(%u) )", stream, var_target, var_pname, (GLvoid**)(inptr_params.get()), size_params);
4829 			this->glGetBufferPointervOES(var_target, var_pname, (GLvoid**)(inptr_params.get()));
4830 			SET_LASTCALL("glGetBufferPointervOES");
4831 			android::base::endTrace();
4832 			break;
4833 		}
4834 		case OP_glCurrentPaletteMatrixOES: {
4835 			android::base::beginTrace("glCurrentPaletteMatrixOES decode");
4836 			GLuint var_matrixpaletteindex = Unpack<GLuint,uint32_t>(ptr + 8);
4837 			if (useChecksum) {
4838 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
4839 					"gles1_decoder_context_t::decode, OP_glCurrentPaletteMatrixOES: GL checksumCalculator failure\n");
4840 			}
4841 			#ifdef CHECK_GL_ERRORS
4842 			GLint err = this->glGetError();
4843 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glCurrentPaletteMatrixOES\n", err);
4844 			#endif
4845 			DECODER_DEBUG_LOG("gles1(%p): glCurrentPaletteMatrixOES(matrixpaletteindex:%u )", stream, var_matrixpaletteindex);
4846 			this->glCurrentPaletteMatrixOES(var_matrixpaletteindex);
4847 			SET_LASTCALL("glCurrentPaletteMatrixOES");
4848 			android::base::endTrace();
4849 			break;
4850 		}
4851 		case OP_glLoadPaletteFromModelViewMatrixOES: {
4852 			android::base::beginTrace("glLoadPaletteFromModelViewMatrixOES decode");
4853 			if (useChecksum) {
4854 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
4855 					"gles1_decoder_context_t::decode, OP_glLoadPaletteFromModelViewMatrixOES: GL checksumCalculator failure\n");
4856 			}
4857 			#ifdef CHECK_GL_ERRORS
4858 			GLint err = this->glGetError();
4859 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glLoadPaletteFromModelViewMatrixOES\n", err);
4860 			#endif
4861 			DECODER_DEBUG_LOG("gles1(%p): glLoadPaletteFromModelViewMatrixOES()", stream);
4862 			this->glLoadPaletteFromModelViewMatrixOES();
4863 			SET_LASTCALL("glLoadPaletteFromModelViewMatrixOES");
4864 			android::base::endTrace();
4865 			break;
4866 		}
4867 		case OP_glMatrixIndexPointerOES: {
4868 			android::base::beginTrace("glMatrixIndexPointerOES decode");
4869 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
4870 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4871 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4872 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4873 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
4874 			if (useChecksum) {
4875 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
4876 					"gles1_decoder_context_t::decode, OP_glMatrixIndexPointerOES: GL checksumCalculator failure\n");
4877 			}
4878 			#ifdef CHECK_GL_ERRORS
4879 			GLint err = this->glGetError();
4880 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMatrixIndexPointerOES\n", err);
4881 			#endif
4882 			DECODER_DEBUG_LOG("gles1(%p): glMatrixIndexPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
4883 			this->glMatrixIndexPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
4884 			SET_LASTCALL("glMatrixIndexPointerOES");
4885 			android::base::endTrace();
4886 			break;
4887 		}
4888 		case OP_glWeightPointerOES: {
4889 			android::base::beginTrace("glWeightPointerOES decode");
4890 			GLint var_size = Unpack<GLint,uint32_t>(ptr + 8);
4891 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
4892 			GLsizei var_stride = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
4893 			uint32_t size_pointer __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
4894 			InputBuffer inptr_pointer(ptr + 8 + 4 + 4 + 4 + 4, size_pointer);
4895 			if (useChecksum) {
4896 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + size_pointer, ptr + 8 + 4 + 4 + 4 + 4 + size_pointer, checksumSize,
4897 					"gles1_decoder_context_t::decode, OP_glWeightPointerOES: GL checksumCalculator failure\n");
4898 			}
4899 			#ifdef CHECK_GL_ERRORS
4900 			GLint err = this->glGetError();
4901 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glWeightPointerOES\n", err);
4902 			#endif
4903 			DECODER_DEBUG_LOG("gles1(%p): glWeightPointerOES(size:%d type:0x%08x stride:%d pointer:%p(%u) )", stream, var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()), size_pointer);
4904 			this->glWeightPointerOES(var_size, var_type, var_stride, (const GLvoid*)(inptr_pointer.get()));
4905 			SET_LASTCALL("glWeightPointerOES");
4906 			android::base::endTrace();
4907 			break;
4908 		}
4909 		case OP_glQueryMatrixxOES: {
4910 			android::base::beginTrace("glQueryMatrixxOES decode");
4911 			uint32_t size_mantissa __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
4912 			uint32_t size_exponent __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
4913 			if (useChecksum) {
4914 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4915 					"gles1_decoder_context_t::decode, OP_glQueryMatrixxOES: GL checksumCalculator failure\n");
4916 			}
4917 			size_t totalTmpSize = size_mantissa;
4918 			totalTmpSize += size_exponent;
4919 			totalTmpSize += sizeof(GLbitfield);
4920 			totalTmpSize += checksumSize;
4921 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
4922 			OutputBuffer outptr_mantissa(&tmpBuf[0], size_mantissa);
4923 			OutputBuffer outptr_exponent(&tmpBuf[0 + size_mantissa], size_exponent);
4924 			#ifdef CHECK_GL_ERRORS
4925 			GLint err = this->glGetError();
4926 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glQueryMatrixxOES\n", err);
4927 			#endif
4928 			DECODER_DEBUG_LOG("gles1(%p): glQueryMatrixxOES(mantissa:%p(%u) exponent:%p(%u) )", stream, (GLfixed*)(outptr_mantissa.get()), size_mantissa, (GLint*)(outptr_exponent.get()), size_exponent);
4929 			*(GLbitfield *)(&tmpBuf[0 + size_mantissa + size_exponent]) = 			this->glQueryMatrixxOES((GLfixed*)(outptr_mantissa.get()), (GLint*)(outptr_exponent.get()));
4930 			outptr_mantissa.flush();
4931 			outptr_exponent.flush();
4932 			if (useChecksum) {
4933 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
4934 			}
4935 			stream->flush();
4936 			SET_LASTCALL("glQueryMatrixxOES");
4937 			android::base::endTrace();
4938 			break;
4939 		}
4940 		case OP_glDepthRangefOES: {
4941 			android::base::beginTrace("glDepthRangefOES decode");
4942 			GLclampf var_zNear = Unpack<GLclampf,uint32_t>(ptr + 8);
4943 			GLclampf var_zFar = Unpack<GLclampf,uint32_t>(ptr + 8 + 4);
4944 			if (useChecksum) {
4945 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
4946 					"gles1_decoder_context_t::decode, OP_glDepthRangefOES: GL checksumCalculator failure\n");
4947 			}
4948 			#ifdef CHECK_GL_ERRORS
4949 			GLint err = this->glGetError();
4950 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDepthRangefOES\n", err);
4951 			#endif
4952 			DECODER_DEBUG_LOG("gles1(%p): glDepthRangefOES(zNear:%f zFar:%f )", stream, var_zNear, var_zFar);
4953 			this->glDepthRangefOES(var_zNear, var_zFar);
4954 			SET_LASTCALL("glDepthRangefOES");
4955 			android::base::endTrace();
4956 			break;
4957 		}
4958 		case OP_glFrustumfOES: {
4959 			android::base::beginTrace("glFrustumfOES decode");
4960 			GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
4961 			GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
4962 			GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
4963 			GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
4964 			GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4965 			GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4966 			if (useChecksum) {
4967 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4968 					"gles1_decoder_context_t::decode, OP_glFrustumfOES: GL checksumCalculator failure\n");
4969 			}
4970 			#ifdef CHECK_GL_ERRORS
4971 			GLint err = this->glGetError();
4972 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFrustumfOES\n", err);
4973 			#endif
4974 			DECODER_DEBUG_LOG("gles1(%p): glFrustumfOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4975 			this->glFrustumfOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4976 			SET_LASTCALL("glFrustumfOES");
4977 			android::base::endTrace();
4978 			break;
4979 		}
4980 		case OP_glOrthofOES: {
4981 			android::base::beginTrace("glOrthofOES decode");
4982 			GLfloat var_left = Unpack<GLfloat,uint32_t>(ptr + 8);
4983 			GLfloat var_right = Unpack<GLfloat,uint32_t>(ptr + 8 + 4);
4984 			GLfloat var_bottom = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
4985 			GLfloat var_top = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4);
4986 			GLfloat var_zNear = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
4987 			GLfloat var_zFar = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
4988 			if (useChecksum) {
4989 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
4990 					"gles1_decoder_context_t::decode, OP_glOrthofOES: GL checksumCalculator failure\n");
4991 			}
4992 			#ifdef CHECK_GL_ERRORS
4993 			GLint err = this->glGetError();
4994 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glOrthofOES\n", err);
4995 			#endif
4996 			DECODER_DEBUG_LOG("gles1(%p): glOrthofOES(left:%f right:%f bottom:%f top:%f zNear:%f zFar:%f )", stream, var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4997 			this->glOrthofOES(var_left, var_right, var_bottom, var_top, var_zNear, var_zFar);
4998 			SET_LASTCALL("glOrthofOES");
4999 			android::base::endTrace();
5000 			break;
5001 		}
5002 		case OP_glClipPlanefOES: {
5003 			android::base::beginTrace("glClipPlanefOES decode");
5004 			GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
5005 			uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5006 			InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
5007 			if (useChecksum) {
5008 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
5009 					"gles1_decoder_context_t::decode, OP_glClipPlanefOES: GL checksumCalculator failure\n");
5010 			}
5011 			#ifdef CHECK_GL_ERRORS
5012 			GLint err = this->glGetError();
5013 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefOES\n", err);
5014 			#endif
5015 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanefOES(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
5016 			this->glClipPlanefOES(var_plane, (const GLfloat*)(inptr_equation.get()));
5017 			SET_LASTCALL("glClipPlanefOES");
5018 			android::base::endTrace();
5019 			break;
5020 		}
5021 		case OP_glClipPlanefIMG: {
5022 			android::base::beginTrace("glClipPlanefIMG decode");
5023 			GLenum var_plane = Unpack<GLenum,uint32_t>(ptr + 8);
5024 			uint32_t size_equation __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5025 			InputBuffer inptr_equation(ptr + 8 + 4 + 4, size_equation);
5026 			if (useChecksum) {
5027 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_equation, ptr + 8 + 4 + 4 + size_equation, checksumSize,
5028 					"gles1_decoder_context_t::decode, OP_glClipPlanefIMG: GL checksumCalculator failure\n");
5029 			}
5030 			#ifdef CHECK_GL_ERRORS
5031 			GLint err = this->glGetError();
5032 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClipPlanefIMG\n", err);
5033 			#endif
5034 			DECODER_DEBUG_LOG("gles1(%p): glClipPlanefIMG(plane:0x%08x equation:%p(%u) )", stream, var_plane, (const GLfloat*)(inptr_equation.get()), size_equation);
5035 			this->glClipPlanefIMG(var_plane, (const GLfloat*)(inptr_equation.get()));
5036 			SET_LASTCALL("glClipPlanefIMG");
5037 			android::base::endTrace();
5038 			break;
5039 		}
5040 		case OP_glGetClipPlanefOES: {
5041 			android::base::beginTrace("glGetClipPlanefOES decode");
5042 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8);
5043 			uint32_t size_eqn __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5044 			if (useChecksum) {
5045 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5046 					"gles1_decoder_context_t::decode, OP_glGetClipPlanefOES: GL checksumCalculator failure\n");
5047 			}
5048 			size_t totalTmpSize = size_eqn;
5049 			totalTmpSize += checksumSize;
5050 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5051 			OutputBuffer outptr_eqn(&tmpBuf[0], size_eqn);
5052 			#ifdef CHECK_GL_ERRORS
5053 			GLint err = this->glGetError();
5054 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetClipPlanefOES\n", err);
5055 			#endif
5056 			DECODER_DEBUG_LOG("gles1(%p): glGetClipPlanefOES(pname:0x%08x eqn:%p(%u) )", stream, var_pname, (GLfloat*)(outptr_eqn.get()), size_eqn);
5057 			this->glGetClipPlanefOES(var_pname, (GLfloat*)(outptr_eqn.get()));
5058 			outptr_eqn.flush();
5059 			if (useChecksum) {
5060 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5061 			}
5062 			stream->flush();
5063 			SET_LASTCALL("glGetClipPlanefOES");
5064 			android::base::endTrace();
5065 			break;
5066 		}
5067 		case OP_glClearDepthfOES: {
5068 			android::base::beginTrace("glClearDepthfOES decode");
5069 			GLclampf var_depth = Unpack<GLclampf,uint32_t>(ptr + 8);
5070 			if (useChecksum) {
5071 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5072 					"gles1_decoder_context_t::decode, OP_glClearDepthfOES: GL checksumCalculator failure\n");
5073 			}
5074 			#ifdef CHECK_GL_ERRORS
5075 			GLint err = this->glGetError();
5076 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glClearDepthfOES\n", err);
5077 			#endif
5078 			DECODER_DEBUG_LOG("gles1(%p): glClearDepthfOES(depth:%f )", stream, var_depth);
5079 			this->glClearDepthfOES(var_depth);
5080 			SET_LASTCALL("glClearDepthfOES");
5081 			android::base::endTrace();
5082 			break;
5083 		}
5084 		case OP_glTexGenfOES: {
5085 			android::base::beginTrace("glTexGenfOES decode");
5086 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5087 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5088 			GLfloat var_param = Unpack<GLfloat,uint32_t>(ptr + 8 + 4 + 4);
5089 			if (useChecksum) {
5090 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5091 					"gles1_decoder_context_t::decode, OP_glTexGenfOES: GL checksumCalculator failure\n");
5092 			}
5093 			#ifdef CHECK_GL_ERRORS
5094 			GLint err = this->glGetError();
5095 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfOES\n", err);
5096 			#endif
5097 			DECODER_DEBUG_LOG("gles1(%p): glTexGenfOES(coord:0x%08x pname:0x%08x param:%f )", stream, var_coord, var_pname, var_param);
5098 			this->glTexGenfOES(var_coord, var_pname, var_param);
5099 			SET_LASTCALL("glTexGenfOES");
5100 			android::base::endTrace();
5101 			break;
5102 		}
5103 		case OP_glTexGenfvOES: {
5104 			android::base::beginTrace("glTexGenfvOES decode");
5105 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5106 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5107 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5108 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5109 			if (useChecksum) {
5110 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5111 					"gles1_decoder_context_t::decode, OP_glTexGenfvOES: GL checksumCalculator failure\n");
5112 			}
5113 			#ifdef CHECK_GL_ERRORS
5114 			GLint err = this->glGetError();
5115 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenfvOES\n", err);
5116 			#endif
5117 			DECODER_DEBUG_LOG("gles1(%p): glTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfloat*)(inptr_params.get()), size_params);
5118 			this->glTexGenfvOES(var_coord, var_pname, (const GLfloat*)(inptr_params.get()));
5119 			SET_LASTCALL("glTexGenfvOES");
5120 			android::base::endTrace();
5121 			break;
5122 		}
5123 		case OP_glTexGeniOES: {
5124 			android::base::beginTrace("glTexGeniOES decode");
5125 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5126 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5127 			GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5128 			if (useChecksum) {
5129 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5130 					"gles1_decoder_context_t::decode, OP_glTexGeniOES: GL checksumCalculator failure\n");
5131 			}
5132 			#ifdef CHECK_GL_ERRORS
5133 			GLint err = this->glGetError();
5134 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGeniOES\n", err);
5135 			#endif
5136 			DECODER_DEBUG_LOG("gles1(%p): glTexGeniOES(coord:0x%08x pname:0x%08x param:%d )", stream, var_coord, var_pname, var_param);
5137 			this->glTexGeniOES(var_coord, var_pname, var_param);
5138 			SET_LASTCALL("glTexGeniOES");
5139 			android::base::endTrace();
5140 			break;
5141 		}
5142 		case OP_glTexGenivOES: {
5143 			android::base::beginTrace("glTexGenivOES decode");
5144 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5145 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5146 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5147 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5148 			if (useChecksum) {
5149 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5150 					"gles1_decoder_context_t::decode, OP_glTexGenivOES: GL checksumCalculator failure\n");
5151 			}
5152 			#ifdef CHECK_GL_ERRORS
5153 			GLint err = this->glGetError();
5154 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenivOES\n", err);
5155 			#endif
5156 			DECODER_DEBUG_LOG("gles1(%p): glTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLint*)(inptr_params.get()), size_params);
5157 			this->glTexGenivOES(var_coord, var_pname, (const GLint*)(inptr_params.get()));
5158 			SET_LASTCALL("glTexGenivOES");
5159 			android::base::endTrace();
5160 			break;
5161 		}
5162 		case OP_glTexGenxOES: {
5163 			android::base::beginTrace("glTexGenxOES decode");
5164 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5165 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5166 			GLfixed var_param = Unpack<GLfixed,uint32_t>(ptr + 8 + 4 + 4);
5167 			if (useChecksum) {
5168 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5169 					"gles1_decoder_context_t::decode, OP_glTexGenxOES: GL checksumCalculator failure\n");
5170 			}
5171 			#ifdef CHECK_GL_ERRORS
5172 			GLint err = this->glGetError();
5173 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxOES\n", err);
5174 			#endif
5175 			DECODER_DEBUG_LOG("gles1(%p): glTexGenxOES(coord:0x%08x pname:0x%08x param:0x%08x )", stream, var_coord, var_pname, var_param);
5176 			this->glTexGenxOES(var_coord, var_pname, var_param);
5177 			SET_LASTCALL("glTexGenxOES");
5178 			android::base::endTrace();
5179 			break;
5180 		}
5181 		case OP_glTexGenxvOES: {
5182 			android::base::beginTrace("glTexGenxvOES decode");
5183 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5184 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5185 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5186 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5187 			if (useChecksum) {
5188 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5189 					"gles1_decoder_context_t::decode, OP_glTexGenxvOES: GL checksumCalculator failure\n");
5190 			}
5191 			#ifdef CHECK_GL_ERRORS
5192 			GLint err = this->glGetError();
5193 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTexGenxvOES\n", err);
5194 			#endif
5195 			DECODER_DEBUG_LOG("gles1(%p): glTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (const GLfixed*)(inptr_params.get()), size_params);
5196 			this->glTexGenxvOES(var_coord, var_pname, (const GLfixed*)(inptr_params.get()));
5197 			SET_LASTCALL("glTexGenxvOES");
5198 			android::base::endTrace();
5199 			break;
5200 		}
5201 		case OP_glGetTexGenfvOES: {
5202 			android::base::beginTrace("glGetTexGenfvOES decode");
5203 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5204 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5205 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5206 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5207 			if (useChecksum) {
5208 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5209 					"gles1_decoder_context_t::decode, OP_glGetTexGenfvOES: GL checksumCalculator failure\n");
5210 			}
5211 			#ifdef CHECK_GL_ERRORS
5212 			GLint err = this->glGetError();
5213 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenfvOES\n", err);
5214 			#endif
5215 			DECODER_DEBUG_LOG("gles1(%p): glGetTexGenfvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfloat*)(inptr_params.get()), size_params);
5216 			this->glGetTexGenfvOES(var_coord, var_pname, (GLfloat*)(inptr_params.get()));
5217 			SET_LASTCALL("glGetTexGenfvOES");
5218 			android::base::endTrace();
5219 			break;
5220 		}
5221 		case OP_glGetTexGenivOES: {
5222 			android::base::beginTrace("glGetTexGenivOES decode");
5223 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5224 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5225 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5226 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5227 			if (useChecksum) {
5228 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5229 					"gles1_decoder_context_t::decode, OP_glGetTexGenivOES: GL checksumCalculator failure\n");
5230 			}
5231 			#ifdef CHECK_GL_ERRORS
5232 			GLint err = this->glGetError();
5233 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenivOES\n", err);
5234 			#endif
5235 			DECODER_DEBUG_LOG("gles1(%p): glGetTexGenivOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLint*)(inptr_params.get()), size_params);
5236 			this->glGetTexGenivOES(var_coord, var_pname, (GLint*)(inptr_params.get()));
5237 			SET_LASTCALL("glGetTexGenivOES");
5238 			android::base::endTrace();
5239 			break;
5240 		}
5241 		case OP_glGetTexGenxvOES: {
5242 			android::base::beginTrace("glGetTexGenxvOES decode");
5243 			GLenum var_coord = Unpack<GLenum,uint32_t>(ptr + 8);
5244 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5245 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5246 			InputBuffer inptr_params(ptr + 8 + 4 + 4 + 4, size_params);
5247 			if (useChecksum) {
5248 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + 4 + size_params, checksumSize,
5249 					"gles1_decoder_context_t::decode, OP_glGetTexGenxvOES: GL checksumCalculator failure\n");
5250 			}
5251 			#ifdef CHECK_GL_ERRORS
5252 			GLint err = this->glGetError();
5253 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetTexGenxvOES\n", err);
5254 			#endif
5255 			DECODER_DEBUG_LOG("gles1(%p): glGetTexGenxvOES(coord:0x%08x pname:0x%08x params:%p(%u) )", stream, var_coord, var_pname, (GLfixed*)(inptr_params.get()), size_params);
5256 			this->glGetTexGenxvOES(var_coord, var_pname, (GLfixed*)(inptr_params.get()));
5257 			SET_LASTCALL("glGetTexGenxvOES");
5258 			android::base::endTrace();
5259 			break;
5260 		}
5261 		case OP_glBindVertexArrayOES: {
5262 			android::base::beginTrace("glBindVertexArrayOES decode");
5263 			GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
5264 			if (useChecksum) {
5265 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5266 					"gles1_decoder_context_t::decode, OP_glBindVertexArrayOES: GL checksumCalculator failure\n");
5267 			}
5268 			#ifdef CHECK_GL_ERRORS
5269 			GLint err = this->glGetError();
5270 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glBindVertexArrayOES\n", err);
5271 			#endif
5272 			DECODER_DEBUG_LOG("gles1(%p): glBindVertexArrayOES(array:%u )", stream, var_array);
5273 			this->glBindVertexArrayOES(var_array);
5274 			SET_LASTCALL("glBindVertexArrayOES");
5275 			android::base::endTrace();
5276 			break;
5277 		}
5278 		case OP_glDeleteVertexArraysOES: {
5279 			android::base::beginTrace("glDeleteVertexArraysOES decode");
5280 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5281 			uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5282 			InputBuffer inptr_arrays(ptr + 8 + 4 + 4, size_arrays);
5283 			if (useChecksum) {
5284 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_arrays, ptr + 8 + 4 + 4 + size_arrays, checksumSize,
5285 					"gles1_decoder_context_t::decode, OP_glDeleteVertexArraysOES: GL checksumCalculator failure\n");
5286 			}
5287 			#ifdef CHECK_GL_ERRORS
5288 			GLint err = this->glGetError();
5289 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteVertexArraysOES\n", err);
5290 			#endif
5291 			DECODER_DEBUG_LOG("gles1(%p): glDeleteVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (const GLuint*)(inptr_arrays.get()), size_arrays);
5292 			this->glDeleteVertexArraysOES_dec(this, var_n, (const GLuint*)(inptr_arrays.get()));
5293 			SET_LASTCALL("glDeleteVertexArraysOES");
5294 			android::base::endTrace();
5295 			break;
5296 		}
5297 		case OP_glGenVertexArraysOES: {
5298 			android::base::beginTrace("glGenVertexArraysOES decode");
5299 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5300 			uint32_t size_arrays __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5301 			if (useChecksum) {
5302 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5303 					"gles1_decoder_context_t::decode, OP_glGenVertexArraysOES: GL checksumCalculator failure\n");
5304 			}
5305 			size_t totalTmpSize = size_arrays;
5306 			totalTmpSize += checksumSize;
5307 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5308 			OutputBuffer outptr_arrays(&tmpBuf[0], size_arrays);
5309 			#ifdef CHECK_GL_ERRORS
5310 			GLint err = this->glGetError();
5311 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenVertexArraysOES\n", err);
5312 			#endif
5313 			DECODER_DEBUG_LOG("gles1(%p): glGenVertexArraysOES(n:%d arrays:%p(%u) )", stream, var_n, (GLuint*)(outptr_arrays.get()), size_arrays);
5314 			this->glGenVertexArraysOES_dec(this, var_n, (GLuint*)(outptr_arrays.get()));
5315 			outptr_arrays.flush();
5316 			if (useChecksum) {
5317 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5318 			}
5319 			stream->flush();
5320 			SET_LASTCALL("glGenVertexArraysOES");
5321 			android::base::endTrace();
5322 			break;
5323 		}
5324 		case OP_glIsVertexArrayOES: {
5325 			android::base::beginTrace("glIsVertexArrayOES decode");
5326 			GLuint var_array = Unpack<GLuint,uint32_t>(ptr + 8);
5327 			if (useChecksum) {
5328 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5329 					"gles1_decoder_context_t::decode, OP_glIsVertexArrayOES: GL checksumCalculator failure\n");
5330 			}
5331 			size_t totalTmpSize = sizeof(GLboolean);
5332 			totalTmpSize += checksumSize;
5333 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5334 			#ifdef CHECK_GL_ERRORS
5335 			GLint err = this->glGetError();
5336 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsVertexArrayOES\n", err);
5337 			#endif
5338 			DECODER_DEBUG_LOG("gles1(%p): glIsVertexArrayOES(array:%u )", stream, var_array);
5339 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsVertexArrayOES(var_array);
5340 			if (useChecksum) {
5341 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5342 			}
5343 			stream->flush();
5344 			SET_LASTCALL("glIsVertexArrayOES");
5345 			android::base::endTrace();
5346 			break;
5347 		}
5348 		case OP_glDiscardFramebufferEXT: {
5349 			android::base::beginTrace("glDiscardFramebufferEXT decode");
5350 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5351 			GLsizei var_numAttachments = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5352 			uint32_t size_attachments __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5353 			InputBuffer inptr_attachments(ptr + 8 + 4 + 4 + 4, size_attachments);
5354 			if (useChecksum) {
5355 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_attachments, ptr + 8 + 4 + 4 + 4 + size_attachments, checksumSize,
5356 					"gles1_decoder_context_t::decode, OP_glDiscardFramebufferEXT: GL checksumCalculator failure\n");
5357 			}
5358 			#ifdef CHECK_GL_ERRORS
5359 			GLint err = this->glGetError();
5360 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDiscardFramebufferEXT\n", err);
5361 			#endif
5362 			DECODER_DEBUG_LOG("gles1(%p): glDiscardFramebufferEXT(target:0x%08x numAttachments:%d attachments:%p(%u) )", stream, var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()), size_attachments);
5363 			this->glDiscardFramebufferEXT(var_target, var_numAttachments, (const GLenum*)(inptr_attachments.get()));
5364 			SET_LASTCALL("glDiscardFramebufferEXT");
5365 			android::base::endTrace();
5366 			break;
5367 		}
5368 		case OP_glMultiDrawArraysEXT: {
5369 			android::base::beginTrace("glMultiDrawArraysEXT decode");
5370 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5371 			uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5372 			InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
5373 			uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
5374 			InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
5375 			GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
5376 			if (useChecksum) {
5377 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
5378 					"gles1_decoder_context_t::decode, OP_glMultiDrawArraysEXT: GL checksumCalculator failure\n");
5379 			}
5380 			#ifdef CHECK_GL_ERRORS
5381 			GLint err = this->glGetError();
5382 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysEXT\n", err);
5383 			#endif
5384 			DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysEXT(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (const GLint*)(inptr_first.get()), size_first, (const GLsizei*)(inptr_count.get()), size_count, var_primcount);
5385 			this->glMultiDrawArraysEXT(var_mode, (const GLint*)(inptr_first.get()), (const GLsizei*)(inptr_count.get()), var_primcount);
5386 			SET_LASTCALL("glMultiDrawArraysEXT");
5387 			android::base::endTrace();
5388 			break;
5389 		}
5390 		case OP_glMultiDrawElementsEXT: {
5391 			android::base::beginTrace("glMultiDrawElementsEXT decode");
5392 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5393 			uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5394 			InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
5395 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
5396 			uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
5397 			InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
5398 			GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
5399 			if (useChecksum) {
5400 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, checksumSize,
5401 					"gles1_decoder_context_t::decode, OP_glMultiDrawElementsEXT: GL checksumCalculator failure\n");
5402 			}
5403 			#ifdef CHECK_GL_ERRORS
5404 			GLint err = this->glGetError();
5405 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsEXT\n", err);
5406 			#endif
5407 			DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsEXT(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid* const*)(inptr_indices.get()), size_indices, var_primcount);
5408 			this->glMultiDrawElementsEXT(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid* const*)(inptr_indices.get()), var_primcount);
5409 			SET_LASTCALL("glMultiDrawElementsEXT");
5410 			android::base::endTrace();
5411 			break;
5412 		}
5413 		case OP_glMultiDrawArraysSUN: {
5414 			android::base::beginTrace("glMultiDrawArraysSUN decode");
5415 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5416 			uint32_t size_first __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5417 			InputBuffer inptr_first(ptr + 8 + 4 + 4, size_first);
5418 			uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_first);
5419 			InputBuffer inptr_count(ptr + 8 + 4 + 4 + size_first + 4, size_count);
5420 			GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_first + 4 + size_count);
5421 			if (useChecksum) {
5422 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_first + 4 + size_count + 4, ptr + 8 + 4 + 4 + size_first + 4 + size_count + 4, checksumSize,
5423 					"gles1_decoder_context_t::decode, OP_glMultiDrawArraysSUN: GL checksumCalculator failure\n");
5424 			}
5425 			#ifdef CHECK_GL_ERRORS
5426 			GLint err = this->glGetError();
5427 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawArraysSUN\n", err);
5428 			#endif
5429 			DECODER_DEBUG_LOG("gles1(%p): glMultiDrawArraysSUN(mode:0x%08x first:%p(%u) count:%p(%u) primcount:%d )", stream, var_mode, (GLint*)(inptr_first.get()), size_first, (GLsizei*)(inptr_count.get()), size_count, var_primcount);
5430 			this->glMultiDrawArraysSUN(var_mode, (GLint*)(inptr_first.get()), (GLsizei*)(inptr_count.get()), var_primcount);
5431 			SET_LASTCALL("glMultiDrawArraysSUN");
5432 			android::base::endTrace();
5433 			break;
5434 		}
5435 		case OP_glMultiDrawElementsSUN: {
5436 			android::base::beginTrace("glMultiDrawElementsSUN decode");
5437 			GLenum var_mode = Unpack<GLenum,uint32_t>(ptr + 8);
5438 			uint32_t size_count __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5439 			InputBuffer inptr_count(ptr + 8 + 4 + 4, size_count);
5440 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + size_count);
5441 			uint32_t size_indices __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4);
5442 			InputBuffer inptr_indices(ptr + 8 + 4 + 4 + size_count + 4 + 4, size_indices);
5443 			GLsizei var_primcount = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices);
5444 			if (useChecksum) {
5445 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, ptr + 8 + 4 + 4 + size_count + 4 + 4 + size_indices + 4, checksumSize,
5446 					"gles1_decoder_context_t::decode, OP_glMultiDrawElementsSUN: GL checksumCalculator failure\n");
5447 			}
5448 			#ifdef CHECK_GL_ERRORS
5449 			GLint err = this->glGetError();
5450 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glMultiDrawElementsSUN\n", err);
5451 			#endif
5452 			DECODER_DEBUG_LOG("gles1(%p): glMultiDrawElementsSUN(mode:0x%08x count:%p(%u) type:0x%08x indices:%p(%u) primcount:%d )", stream, var_mode, (const GLsizei*)(inptr_count.get()), size_count, var_type, (const GLvoid**)(inptr_indices.get()), size_indices, var_primcount);
5453 			this->glMultiDrawElementsSUN(var_mode, (const GLsizei*)(inptr_count.get()), var_type, (const GLvoid**)(inptr_indices.get()), var_primcount);
5454 			SET_LASTCALL("glMultiDrawElementsSUN");
5455 			android::base::endTrace();
5456 			break;
5457 		}
5458 		case OP_glRenderbufferStorageMultisampleIMG: {
5459 			android::base::beginTrace("glRenderbufferStorageMultisampleIMG decode");
5460 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5461 			GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5462 			GLenum var_internalformat = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
5463 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
5464 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5465 			if (useChecksum) {
5466 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
5467 					"gles1_decoder_context_t::decode, OP_glRenderbufferStorageMultisampleIMG: GL checksumCalculator failure\n");
5468 			}
5469 			#ifdef CHECK_GL_ERRORS
5470 			GLint err = this->glGetError();
5471 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glRenderbufferStorageMultisampleIMG\n", err);
5472 			#endif
5473 			DECODER_DEBUG_LOG("gles1(%p): glRenderbufferStorageMultisampleIMG(target:0x%08x samples:%d internalformat:0x%08x width:%d height:%d )", stream, var_target, var_samples, var_internalformat, var_width, var_height);
5474 			this->glRenderbufferStorageMultisampleIMG(var_target, var_samples, var_internalformat, var_width, var_height);
5475 			SET_LASTCALL("glRenderbufferStorageMultisampleIMG");
5476 			android::base::endTrace();
5477 			break;
5478 		}
5479 		case OP_glFramebufferTexture2DMultisampleIMG: {
5480 			android::base::beginTrace("glFramebufferTexture2DMultisampleIMG decode");
5481 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5482 			GLenum var_attachment = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5483 			GLenum var_textarget = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4);
5484 			GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
5485 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5486 			GLsizei var_samples = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
5487 			if (useChecksum) {
5488 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
5489 					"gles1_decoder_context_t::decode, OP_glFramebufferTexture2DMultisampleIMG: GL checksumCalculator failure\n");
5490 			}
5491 			#ifdef CHECK_GL_ERRORS
5492 			GLint err = this->glGetError();
5493 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFramebufferTexture2DMultisampleIMG\n", err);
5494 			#endif
5495 			DECODER_DEBUG_LOG("gles1(%p): glFramebufferTexture2DMultisampleIMG(target:0x%08x attachment:0x%08x textarget:0x%08x texture:%u level:%d samples:%d )", stream, var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
5496 			this->glFramebufferTexture2DMultisampleIMG(var_target, var_attachment, var_textarget, var_texture, var_level, var_samples);
5497 			SET_LASTCALL("glFramebufferTexture2DMultisampleIMG");
5498 			android::base::endTrace();
5499 			break;
5500 		}
5501 		case OP_glDeleteFencesNV: {
5502 			android::base::beginTrace("glDeleteFencesNV decode");
5503 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5504 			uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5505 			InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
5506 			if (useChecksum) {
5507 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
5508 					"gles1_decoder_context_t::decode, OP_glDeleteFencesNV: GL checksumCalculator failure\n");
5509 			}
5510 			#ifdef CHECK_GL_ERRORS
5511 			GLint err = this->glGetError();
5512 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDeleteFencesNV\n", err);
5513 			#endif
5514 			DECODER_DEBUG_LOG("gles1(%p): glDeleteFencesNV(n:%d fences:%p(%u) )", stream, var_n, (const GLuint*)(inptr_fences.get()), size_fences);
5515 			this->glDeleteFencesNV(var_n, (const GLuint*)(inptr_fences.get()));
5516 			SET_LASTCALL("glDeleteFencesNV");
5517 			android::base::endTrace();
5518 			break;
5519 		}
5520 		case OP_glGenFencesNV: {
5521 			android::base::beginTrace("glGenFencesNV decode");
5522 			GLsizei var_n = Unpack<GLsizei,uint32_t>(ptr + 8);
5523 			uint32_t size_fences __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5524 			InputBuffer inptr_fences(ptr + 8 + 4 + 4, size_fences);
5525 			if (useChecksum) {
5526 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_fences, ptr + 8 + 4 + 4 + size_fences, checksumSize,
5527 					"gles1_decoder_context_t::decode, OP_glGenFencesNV: GL checksumCalculator failure\n");
5528 			}
5529 			#ifdef CHECK_GL_ERRORS
5530 			GLint err = this->glGetError();
5531 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGenFencesNV\n", err);
5532 			#endif
5533 			DECODER_DEBUG_LOG("gles1(%p): glGenFencesNV(n:%d fences:%p(%u) )", stream, var_n, (GLuint*)(inptr_fences.get()), size_fences);
5534 			this->glGenFencesNV(var_n, (GLuint*)(inptr_fences.get()));
5535 			SET_LASTCALL("glGenFencesNV");
5536 			android::base::endTrace();
5537 			break;
5538 		}
5539 		case OP_glIsFenceNV: {
5540 			android::base::beginTrace("glIsFenceNV decode");
5541 			GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5542 			if (useChecksum) {
5543 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5544 					"gles1_decoder_context_t::decode, OP_glIsFenceNV: GL checksumCalculator failure\n");
5545 			}
5546 			size_t totalTmpSize = sizeof(GLboolean);
5547 			totalTmpSize += checksumSize;
5548 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5549 			#ifdef CHECK_GL_ERRORS
5550 			GLint err = this->glGetError();
5551 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glIsFenceNV\n", err);
5552 			#endif
5553 			DECODER_DEBUG_LOG("gles1(%p): glIsFenceNV(fence:%u )", stream, var_fence);
5554 			*(GLboolean *)(&tmpBuf[0]) = 			this->glIsFenceNV(var_fence);
5555 			if (useChecksum) {
5556 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5557 			}
5558 			stream->flush();
5559 			SET_LASTCALL("glIsFenceNV");
5560 			android::base::endTrace();
5561 			break;
5562 		}
5563 		case OP_glTestFenceNV: {
5564 			android::base::beginTrace("glTestFenceNV decode");
5565 			GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5566 			if (useChecksum) {
5567 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5568 					"gles1_decoder_context_t::decode, OP_glTestFenceNV: GL checksumCalculator failure\n");
5569 			}
5570 			size_t totalTmpSize = sizeof(GLboolean);
5571 			totalTmpSize += checksumSize;
5572 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5573 			#ifdef CHECK_GL_ERRORS
5574 			GLint err = this->glGetError();
5575 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glTestFenceNV\n", err);
5576 			#endif
5577 			DECODER_DEBUG_LOG("gles1(%p): glTestFenceNV(fence:%u )", stream, var_fence);
5578 			*(GLboolean *)(&tmpBuf[0]) = 			this->glTestFenceNV(var_fence);
5579 			if (useChecksum) {
5580 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5581 			}
5582 			stream->flush();
5583 			SET_LASTCALL("glTestFenceNV");
5584 			android::base::endTrace();
5585 			break;
5586 		}
5587 		case OP_glGetFenceivNV: {
5588 			android::base::beginTrace("glGetFenceivNV decode");
5589 			GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5590 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5591 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5592 			if (useChecksum) {
5593 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5594 					"gles1_decoder_context_t::decode, OP_glGetFenceivNV: GL checksumCalculator failure\n");
5595 			}
5596 			size_t totalTmpSize = size_params;
5597 			totalTmpSize += checksumSize;
5598 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5599 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
5600 			#ifdef CHECK_GL_ERRORS
5601 			GLint err = this->glGetError();
5602 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetFenceivNV\n", err);
5603 			#endif
5604 			DECODER_DEBUG_LOG("gles1(%p): glGetFenceivNV(fence:%u pname:0x%08x params:%p(%u) )", stream, var_fence, var_pname, (GLint*)(outptr_params.get()), size_params);
5605 			this->glGetFenceivNV(var_fence, var_pname, (GLint*)(outptr_params.get()));
5606 			outptr_params.flush();
5607 			if (useChecksum) {
5608 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5609 			}
5610 			stream->flush();
5611 			SET_LASTCALL("glGetFenceivNV");
5612 			android::base::endTrace();
5613 			break;
5614 		}
5615 		case OP_glFinishFenceNV: {
5616 			android::base::beginTrace("glFinishFenceNV decode");
5617 			GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5618 			if (useChecksum) {
5619 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5620 					"gles1_decoder_context_t::decode, OP_glFinishFenceNV: GL checksumCalculator failure\n");
5621 			}
5622 			#ifdef CHECK_GL_ERRORS
5623 			GLint err = this->glGetError();
5624 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glFinishFenceNV\n", err);
5625 			#endif
5626 			DECODER_DEBUG_LOG("gles1(%p): glFinishFenceNV(fence:%u )", stream, var_fence);
5627 			this->glFinishFenceNV(var_fence);
5628 			SET_LASTCALL("glFinishFenceNV");
5629 			android::base::endTrace();
5630 			break;
5631 		}
5632 		case OP_glSetFenceNV: {
5633 			android::base::beginTrace("glSetFenceNV decode");
5634 			GLuint var_fence = Unpack<GLuint,uint32_t>(ptr + 8);
5635 			GLenum var_condition = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5636 			if (useChecksum) {
5637 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4, ptr + 8 + 4 + 4, checksumSize,
5638 					"gles1_decoder_context_t::decode, OP_glSetFenceNV: GL checksumCalculator failure\n");
5639 			}
5640 			#ifdef CHECK_GL_ERRORS
5641 			GLint err = this->glGetError();
5642 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glSetFenceNV\n", err);
5643 			#endif
5644 			DECODER_DEBUG_LOG("gles1(%p): glSetFenceNV(fence:%u condition:0x%08x )", stream, var_fence, var_condition);
5645 			this->glSetFenceNV(var_fence, var_condition);
5646 			SET_LASTCALL("glSetFenceNV");
5647 			android::base::endTrace();
5648 			break;
5649 		}
5650 		case OP_glGetDriverControlsQCOM: {
5651 			android::base::beginTrace("glGetDriverControlsQCOM decode");
5652 			uint32_t size_num __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5653 			GLsizei var_size = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5654 			uint32_t size_driverControls __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5655 			if (useChecksum) {
5656 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5657 					"gles1_decoder_context_t::decode, OP_glGetDriverControlsQCOM: GL checksumCalculator failure\n");
5658 			}
5659 			size_t totalTmpSize = size_num;
5660 			totalTmpSize += size_driverControls;
5661 			totalTmpSize += checksumSize;
5662 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5663 			OutputBuffer outptr_num(&tmpBuf[0], size_num);
5664 			OutputBuffer outptr_driverControls(&tmpBuf[0 + size_num], size_driverControls);
5665 			#ifdef CHECK_GL_ERRORS
5666 			GLint err = this->glGetError();
5667 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlsQCOM\n", err);
5668 			#endif
5669 			DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlsQCOM(num:%p(%u) size:%d driverControls:%p(%u) )", stream, (GLint*)(outptr_num.get()), size_num, var_size, (GLuint*)(outptr_driverControls.get()), size_driverControls);
5670 			this->glGetDriverControlsQCOM((GLint*)(outptr_num.get()), var_size, (GLuint*)(outptr_driverControls.get()));
5671 			outptr_num.flush();
5672 			outptr_driverControls.flush();
5673 			if (useChecksum) {
5674 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5675 			}
5676 			stream->flush();
5677 			SET_LASTCALL("glGetDriverControlsQCOM");
5678 			android::base::endTrace();
5679 			break;
5680 		}
5681 		case OP_glGetDriverControlStringQCOM: {
5682 			android::base::beginTrace("glGetDriverControlStringQCOM decode");
5683 			GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5684 			GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4);
5685 			uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5686 			uint32_t size_driverControlString __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4);
5687 			if (useChecksum) {
5688 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4, checksumSize,
5689 					"gles1_decoder_context_t::decode, OP_glGetDriverControlStringQCOM: GL checksumCalculator failure\n");
5690 			}
5691 			size_t totalTmpSize = size_length;
5692 			totalTmpSize += size_driverControlString;
5693 			totalTmpSize += checksumSize;
5694 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5695 			OutputBuffer outptr_length(&tmpBuf[0], size_length);
5696 			OutputBuffer outptr_driverControlString(&tmpBuf[0 + size_length], size_driverControlString);
5697 			#ifdef CHECK_GL_ERRORS
5698 			GLint err = this->glGetError();
5699 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetDriverControlStringQCOM\n", err);
5700 			#endif
5701 			DECODER_DEBUG_LOG("gles1(%p): glGetDriverControlStringQCOM(driverControl:%u bufSize:%d length:%p(%u) driverControlString:%p(%u) )", stream, var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), size_length, (GLchar*)(outptr_driverControlString.get()), size_driverControlString);
5702 			this->glGetDriverControlStringQCOM(var_driverControl, var_bufSize, (GLsizei*)(outptr_length.get()), (GLchar*)(outptr_driverControlString.get()));
5703 			outptr_length.flush();
5704 			outptr_driverControlString.flush();
5705 			if (useChecksum) {
5706 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5707 			}
5708 			stream->flush();
5709 			SET_LASTCALL("glGetDriverControlStringQCOM");
5710 			android::base::endTrace();
5711 			break;
5712 		}
5713 		case OP_glEnableDriverControlQCOM: {
5714 			android::base::beginTrace("glEnableDriverControlQCOM decode");
5715 			GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5716 			if (useChecksum) {
5717 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5718 					"gles1_decoder_context_t::decode, OP_glEnableDriverControlQCOM: GL checksumCalculator failure\n");
5719 			}
5720 			#ifdef CHECK_GL_ERRORS
5721 			GLint err = this->glGetError();
5722 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEnableDriverControlQCOM\n", err);
5723 			#endif
5724 			DECODER_DEBUG_LOG("gles1(%p): glEnableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
5725 			this->glEnableDriverControlQCOM(var_driverControl);
5726 			SET_LASTCALL("glEnableDriverControlQCOM");
5727 			android::base::endTrace();
5728 			break;
5729 		}
5730 		case OP_glDisableDriverControlQCOM: {
5731 			android::base::beginTrace("glDisableDriverControlQCOM decode");
5732 			GLuint var_driverControl = Unpack<GLuint,uint32_t>(ptr + 8);
5733 			if (useChecksum) {
5734 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
5735 					"gles1_decoder_context_t::decode, OP_glDisableDriverControlQCOM: GL checksumCalculator failure\n");
5736 			}
5737 			#ifdef CHECK_GL_ERRORS
5738 			GLint err = this->glGetError();
5739 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glDisableDriverControlQCOM\n", err);
5740 			#endif
5741 			DECODER_DEBUG_LOG("gles1(%p): glDisableDriverControlQCOM(driverControl:%u )", stream, var_driverControl);
5742 			this->glDisableDriverControlQCOM(var_driverControl);
5743 			SET_LASTCALL("glDisableDriverControlQCOM");
5744 			android::base::endTrace();
5745 			break;
5746 		}
5747 		case OP_glExtGetTexturesQCOM: {
5748 			android::base::beginTrace("glExtGetTexturesQCOM decode");
5749 			uint32_t size_textures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5750 			GLint var_maxTextures = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5751 			uint32_t size_numTextures __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5752 			if (useChecksum) {
5753 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5754 					"gles1_decoder_context_t::decode, OP_glExtGetTexturesQCOM: GL checksumCalculator failure\n");
5755 			}
5756 			size_t totalTmpSize = size_textures;
5757 			totalTmpSize += size_numTextures;
5758 			totalTmpSize += checksumSize;
5759 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5760 			OutputBuffer outptr_textures(&tmpBuf[0], size_textures);
5761 			OutputBuffer outptr_numTextures(&tmpBuf[0 + size_textures], size_numTextures);
5762 			#ifdef CHECK_GL_ERRORS
5763 			GLint err = this->glGetError();
5764 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexturesQCOM\n", err);
5765 			#endif
5766 			DECODER_DEBUG_LOG("gles1(%p): glExtGetTexturesQCOM(textures:%p(%u) maxTextures:%d numTextures:%p(%u) )", stream, (GLuint*)(outptr_textures.get()), size_textures, var_maxTextures, (GLint*)(outptr_numTextures.get()), size_numTextures);
5767 			this->glExtGetTexturesQCOM((GLuint*)(outptr_textures.get()), var_maxTextures, (GLint*)(outptr_numTextures.get()));
5768 			outptr_textures.flush();
5769 			outptr_numTextures.flush();
5770 			if (useChecksum) {
5771 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5772 			}
5773 			stream->flush();
5774 			SET_LASTCALL("glExtGetTexturesQCOM");
5775 			android::base::endTrace();
5776 			break;
5777 		}
5778 		case OP_glExtGetBuffersQCOM: {
5779 			android::base::beginTrace("glExtGetBuffersQCOM decode");
5780 			uint32_t size_buffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5781 			GLint var_maxBuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5782 			uint32_t size_numBuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5783 			if (useChecksum) {
5784 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5785 					"gles1_decoder_context_t::decode, OP_glExtGetBuffersQCOM: GL checksumCalculator failure\n");
5786 			}
5787 			size_t totalTmpSize = size_buffers;
5788 			totalTmpSize += size_numBuffers;
5789 			totalTmpSize += checksumSize;
5790 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5791 			OutputBuffer outptr_buffers(&tmpBuf[0], size_buffers);
5792 			OutputBuffer outptr_numBuffers(&tmpBuf[0 + size_buffers], size_numBuffers);
5793 			#ifdef CHECK_GL_ERRORS
5794 			GLint err = this->glGetError();
5795 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBuffersQCOM\n", err);
5796 			#endif
5797 			DECODER_DEBUG_LOG("gles1(%p): glExtGetBuffersQCOM(buffers:%p(%u) maxBuffers:%d numBuffers:%p(%u) )", stream, (GLuint*)(outptr_buffers.get()), size_buffers, var_maxBuffers, (GLint*)(outptr_numBuffers.get()), size_numBuffers);
5798 			this->glExtGetBuffersQCOM((GLuint*)(outptr_buffers.get()), var_maxBuffers, (GLint*)(outptr_numBuffers.get()));
5799 			outptr_buffers.flush();
5800 			outptr_numBuffers.flush();
5801 			if (useChecksum) {
5802 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5803 			}
5804 			stream->flush();
5805 			SET_LASTCALL("glExtGetBuffersQCOM");
5806 			android::base::endTrace();
5807 			break;
5808 		}
5809 		case OP_glExtGetRenderbuffersQCOM: {
5810 			android::base::beginTrace("glExtGetRenderbuffersQCOM decode");
5811 			uint32_t size_renderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5812 			GLint var_maxRenderbuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5813 			uint32_t size_numRenderbuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5814 			if (useChecksum) {
5815 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5816 					"gles1_decoder_context_t::decode, OP_glExtGetRenderbuffersQCOM: GL checksumCalculator failure\n");
5817 			}
5818 			size_t totalTmpSize = size_renderbuffers;
5819 			totalTmpSize += size_numRenderbuffers;
5820 			totalTmpSize += checksumSize;
5821 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5822 			OutputBuffer outptr_renderbuffers(&tmpBuf[0], size_renderbuffers);
5823 			OutputBuffer outptr_numRenderbuffers(&tmpBuf[0 + size_renderbuffers], size_numRenderbuffers);
5824 			#ifdef CHECK_GL_ERRORS
5825 			GLint err = this->glGetError();
5826 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetRenderbuffersQCOM\n", err);
5827 			#endif
5828 			DECODER_DEBUG_LOG("gles1(%p): glExtGetRenderbuffersQCOM(renderbuffers:%p(%u) maxRenderbuffers:%d numRenderbuffers:%p(%u) )", stream, (GLuint*)(outptr_renderbuffers.get()), size_renderbuffers, var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()), size_numRenderbuffers);
5829 			this->glExtGetRenderbuffersQCOM((GLuint*)(outptr_renderbuffers.get()), var_maxRenderbuffers, (GLint*)(outptr_numRenderbuffers.get()));
5830 			outptr_renderbuffers.flush();
5831 			outptr_numRenderbuffers.flush();
5832 			if (useChecksum) {
5833 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5834 			}
5835 			stream->flush();
5836 			SET_LASTCALL("glExtGetRenderbuffersQCOM");
5837 			android::base::endTrace();
5838 			break;
5839 		}
5840 		case OP_glExtGetFramebuffersQCOM: {
5841 			android::base::beginTrace("glExtGetFramebuffersQCOM decode");
5842 			uint32_t size_framebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5843 			GLint var_maxFramebuffers = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5844 			uint32_t size_numFramebuffers __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5845 			if (useChecksum) {
5846 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5847 					"gles1_decoder_context_t::decode, OP_glExtGetFramebuffersQCOM: GL checksumCalculator failure\n");
5848 			}
5849 			size_t totalTmpSize = size_framebuffers;
5850 			totalTmpSize += size_numFramebuffers;
5851 			totalTmpSize += checksumSize;
5852 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5853 			OutputBuffer outptr_framebuffers(&tmpBuf[0], size_framebuffers);
5854 			OutputBuffer outptr_numFramebuffers(&tmpBuf[0 + size_framebuffers], size_numFramebuffers);
5855 			#ifdef CHECK_GL_ERRORS
5856 			GLint err = this->glGetError();
5857 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetFramebuffersQCOM\n", err);
5858 			#endif
5859 			DECODER_DEBUG_LOG("gles1(%p): glExtGetFramebuffersQCOM(framebuffers:%p(%u) maxFramebuffers:%d numFramebuffers:%p(%u) )", stream, (GLuint*)(outptr_framebuffers.get()), size_framebuffers, var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()), size_numFramebuffers);
5860 			this->glExtGetFramebuffersQCOM((GLuint*)(outptr_framebuffers.get()), var_maxFramebuffers, (GLint*)(outptr_numFramebuffers.get()));
5861 			outptr_framebuffers.flush();
5862 			outptr_numFramebuffers.flush();
5863 			if (useChecksum) {
5864 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5865 			}
5866 			stream->flush();
5867 			SET_LASTCALL("glExtGetFramebuffersQCOM");
5868 			android::base::endTrace();
5869 			break;
5870 		}
5871 		case OP_glExtGetTexLevelParameterivQCOM: {
5872 			android::base::beginTrace("glExtGetTexLevelParameterivQCOM decode");
5873 			GLuint var_texture = Unpack<GLuint,uint32_t>(ptr + 8);
5874 			GLenum var_face = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5875 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5876 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4);
5877 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5878 			if (useChecksum) {
5879 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
5880 					"gles1_decoder_context_t::decode, OP_glExtGetTexLevelParameterivQCOM: GL checksumCalculator failure\n");
5881 			}
5882 			size_t totalTmpSize = size_params;
5883 			totalTmpSize += checksumSize;
5884 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5885 			OutputBuffer outptr_params(&tmpBuf[0], size_params);
5886 			#ifdef CHECK_GL_ERRORS
5887 			GLint err = this->glGetError();
5888 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexLevelParameterivQCOM\n", err);
5889 			#endif
5890 			DECODER_DEBUG_LOG("gles1(%p): glExtGetTexLevelParameterivQCOM(texture:%u face:0x%08x level:%d pname:0x%08x params:%p(%u) )", stream, var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()), size_params);
5891 			this->glExtGetTexLevelParameterivQCOM(var_texture, var_face, var_level, var_pname, (GLint*)(outptr_params.get()));
5892 			outptr_params.flush();
5893 			if (useChecksum) {
5894 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5895 			}
5896 			stream->flush();
5897 			SET_LASTCALL("glExtGetTexLevelParameterivQCOM");
5898 			android::base::endTrace();
5899 			break;
5900 		}
5901 		case OP_glExtTexObjectStateOverrideiQCOM: {
5902 			android::base::beginTrace("glExtTexObjectStateOverrideiQCOM decode");
5903 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5904 			GLenum var_pname = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
5905 			GLint var_param = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5906 			if (useChecksum) {
5907 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5908 					"gles1_decoder_context_t::decode, OP_glExtTexObjectStateOverrideiQCOM: GL checksumCalculator failure\n");
5909 			}
5910 			#ifdef CHECK_GL_ERRORS
5911 			GLint err = this->glGetError();
5912 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtTexObjectStateOverrideiQCOM\n", err);
5913 			#endif
5914 			DECODER_DEBUG_LOG("gles1(%p): glExtTexObjectStateOverrideiQCOM(target:0x%08x pname:0x%08x param:%d )", stream, var_target, var_pname, var_param);
5915 			this->glExtTexObjectStateOverrideiQCOM(var_target, var_pname, var_param);
5916 			SET_LASTCALL("glExtTexObjectStateOverrideiQCOM");
5917 			android::base::endTrace();
5918 			break;
5919 		}
5920 		case OP_glExtGetTexSubImageQCOM: {
5921 			android::base::beginTrace("glExtGetTexSubImageQCOM decode");
5922 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5923 			GLint var_level = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5924 			GLint var_xoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4);
5925 			GLint var_yoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4);
5926 			GLint var_zoffset = Unpack<GLint,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
5927 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
5928 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
5929 			GLsizei var_depth = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5930 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5931 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5932 			uint32_t size_texels __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
5933 			if (useChecksum) {
5934 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
5935 					"gles1_decoder_context_t::decode, OP_glExtGetTexSubImageQCOM: GL checksumCalculator failure\n");
5936 			}
5937 			size_t totalTmpSize = size_texels;
5938 			totalTmpSize += checksumSize;
5939 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5940 			OutputBuffer outptr_texels(&tmpBuf[0], size_texels);
5941 			#ifdef CHECK_GL_ERRORS
5942 			GLint err = this->glGetError();
5943 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetTexSubImageQCOM\n", err);
5944 			#endif
5945 			DECODER_DEBUG_LOG("gles1(%p): glExtGetTexSubImageQCOM(target:0x%08x level:%d xoffset:%d yoffset:%d zoffset:%d width:%d height:%d depth:%d format:0x%08x type:0x%08x texels:%p(%u) )", stream, var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(outptr_texels.get()), size_texels);
5946 			this->glExtGetTexSubImageQCOM(var_target, var_level, var_xoffset, var_yoffset, var_zoffset, var_width, var_height, var_depth, var_format, var_type, (GLvoid*)(outptr_texels.get()));
5947 			outptr_texels.flush();
5948 			if (useChecksum) {
5949 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
5950 			}
5951 			stream->flush();
5952 			SET_LASTCALL("glExtGetTexSubImageQCOM");
5953 			android::base::endTrace();
5954 			break;
5955 		}
5956 		case OP_glExtGetBufferPointervQCOM: {
5957 			android::base::beginTrace("glExtGetBufferPointervQCOM decode");
5958 			GLenum var_target = Unpack<GLenum,uint32_t>(ptr + 8);
5959 			uint32_t size_params __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4);
5960 			InputBuffer inptr_params(ptr + 8 + 4 + 4, size_params);
5961 			if (useChecksum) {
5962 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + size_params, ptr + 8 + 4 + 4 + size_params, checksumSize,
5963 					"gles1_decoder_context_t::decode, OP_glExtGetBufferPointervQCOM: GL checksumCalculator failure\n");
5964 			}
5965 			#ifdef CHECK_GL_ERRORS
5966 			GLint err = this->glGetError();
5967 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetBufferPointervQCOM\n", err);
5968 			#endif
5969 			DECODER_DEBUG_LOG("gles1(%p): glExtGetBufferPointervQCOM(target:0x%08x params:%p(%u) )", stream, var_target, (GLvoid**)(inptr_params.get()), size_params);
5970 			this->glExtGetBufferPointervQCOM(var_target, (GLvoid**)(inptr_params.get()));
5971 			SET_LASTCALL("glExtGetBufferPointervQCOM");
5972 			android::base::endTrace();
5973 			break;
5974 		}
5975 		case OP_glExtGetShadersQCOM: {
5976 			android::base::beginTrace("glExtGetShadersQCOM decode");
5977 			uint32_t size_shaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
5978 			GLint var_maxShaders = Unpack<GLint,uint32_t>(ptr + 8 + 4);
5979 			uint32_t size_numShaders __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
5980 			if (useChecksum) {
5981 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
5982 					"gles1_decoder_context_t::decode, OP_glExtGetShadersQCOM: GL checksumCalculator failure\n");
5983 			}
5984 			size_t totalTmpSize = size_shaders;
5985 			totalTmpSize += size_numShaders;
5986 			totalTmpSize += checksumSize;
5987 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
5988 			OutputBuffer outptr_shaders(&tmpBuf[0], size_shaders);
5989 			OutputBuffer outptr_numShaders(&tmpBuf[0 + size_shaders], size_numShaders);
5990 			#ifdef CHECK_GL_ERRORS
5991 			GLint err = this->glGetError();
5992 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetShadersQCOM\n", err);
5993 			#endif
5994 			DECODER_DEBUG_LOG("gles1(%p): glExtGetShadersQCOM(shaders:%p(%u) maxShaders:%d numShaders:%p(%u) )", stream, (GLuint*)(outptr_shaders.get()), size_shaders, var_maxShaders, (GLint*)(outptr_numShaders.get()), size_numShaders);
5995 			this->glExtGetShadersQCOM((GLuint*)(outptr_shaders.get()), var_maxShaders, (GLint*)(outptr_numShaders.get()));
5996 			outptr_shaders.flush();
5997 			outptr_numShaders.flush();
5998 			if (useChecksum) {
5999 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6000 			}
6001 			stream->flush();
6002 			SET_LASTCALL("glExtGetShadersQCOM");
6003 			android::base::endTrace();
6004 			break;
6005 		}
6006 		case OP_glExtGetProgramsQCOM: {
6007 			android::base::beginTrace("glExtGetProgramsQCOM decode");
6008 			uint32_t size_programs __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8);
6009 			GLint var_maxPrograms = Unpack<GLint,uint32_t>(ptr + 8 + 4);
6010 			uint32_t size_numPrograms __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
6011 			if (useChecksum) {
6012 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4, checksumSize,
6013 					"gles1_decoder_context_t::decode, OP_glExtGetProgramsQCOM: GL checksumCalculator failure\n");
6014 			}
6015 			size_t totalTmpSize = size_programs;
6016 			totalTmpSize += size_numPrograms;
6017 			totalTmpSize += checksumSize;
6018 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6019 			OutputBuffer outptr_programs(&tmpBuf[0], size_programs);
6020 			OutputBuffer outptr_numPrograms(&tmpBuf[0 + size_programs], size_numPrograms);
6021 			#ifdef CHECK_GL_ERRORS
6022 			GLint err = this->glGetError();
6023 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramsQCOM\n", err);
6024 			#endif
6025 			DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramsQCOM(programs:%p(%u) maxPrograms:%d numPrograms:%p(%u) )", stream, (GLuint*)(outptr_programs.get()), size_programs, var_maxPrograms, (GLint*)(outptr_numPrograms.get()), size_numPrograms);
6026 			this->glExtGetProgramsQCOM((GLuint*)(outptr_programs.get()), var_maxPrograms, (GLint*)(outptr_numPrograms.get()));
6027 			outptr_programs.flush();
6028 			outptr_numPrograms.flush();
6029 			if (useChecksum) {
6030 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6031 			}
6032 			stream->flush();
6033 			SET_LASTCALL("glExtGetProgramsQCOM");
6034 			android::base::endTrace();
6035 			break;
6036 		}
6037 		case OP_glExtIsProgramBinaryQCOM: {
6038 			android::base::beginTrace("glExtIsProgramBinaryQCOM decode");
6039 			GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
6040 			if (useChecksum) {
6041 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
6042 					"gles1_decoder_context_t::decode, OP_glExtIsProgramBinaryQCOM: GL checksumCalculator failure\n");
6043 			}
6044 			size_t totalTmpSize = sizeof(GLboolean);
6045 			totalTmpSize += checksumSize;
6046 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6047 			#ifdef CHECK_GL_ERRORS
6048 			GLint err = this->glGetError();
6049 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtIsProgramBinaryQCOM\n", err);
6050 			#endif
6051 			DECODER_DEBUG_LOG("gles1(%p): glExtIsProgramBinaryQCOM(program:%u )", stream, var_program);
6052 			*(GLboolean *)(&tmpBuf[0]) = 			this->glExtIsProgramBinaryQCOM(var_program);
6053 			if (useChecksum) {
6054 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6055 			}
6056 			stream->flush();
6057 			SET_LASTCALL("glExtIsProgramBinaryQCOM");
6058 			android::base::endTrace();
6059 			break;
6060 		}
6061 		case OP_glExtGetProgramBinarySourceQCOM: {
6062 			android::base::beginTrace("glExtGetProgramBinarySourceQCOM decode");
6063 			GLuint var_program = Unpack<GLuint,uint32_t>(ptr + 8);
6064 			GLenum var_shadertype = Unpack<GLenum,uint32_t>(ptr + 8 + 4);
6065 			uint32_t size_source __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4);
6066 			InputBuffer inptr_source(ptr + 8 + 4 + 4 + 4, size_source);
6067 			uint32_t size_length __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + size_source);
6068 			InputBuffer inptr_length(ptr + 8 + 4 + 4 + 4 + size_source + 4, size_length);
6069 			if (useChecksum) {
6070 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + size_source + 4 + size_length, ptr + 8 + 4 + 4 + 4 + size_source + 4 + size_length, checksumSize,
6071 					"gles1_decoder_context_t::decode, OP_glExtGetProgramBinarySourceQCOM: GL checksumCalculator failure\n");
6072 			}
6073 			#ifdef CHECK_GL_ERRORS
6074 			GLint err = this->glGetError();
6075 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glExtGetProgramBinarySourceQCOM\n", err);
6076 			#endif
6077 			DECODER_DEBUG_LOG("gles1(%p): glExtGetProgramBinarySourceQCOM(program:%u shadertype:0x%08x source:%p(%u) length:%p(%u) )", stream, var_program, var_shadertype, (GLchar*)(inptr_source.get()), size_source, (GLint*)(inptr_length.get()), size_length);
6078 			this->glExtGetProgramBinarySourceQCOM(var_program, var_shadertype, (GLchar*)(inptr_source.get()), (GLint*)(inptr_length.get()));
6079 			SET_LASTCALL("glExtGetProgramBinarySourceQCOM");
6080 			android::base::endTrace();
6081 			break;
6082 		}
6083 		case OP_glStartTilingQCOM: {
6084 			android::base::beginTrace("glStartTilingQCOM decode");
6085 			GLuint var_x = Unpack<GLuint,uint32_t>(ptr + 8);
6086 			GLuint var_y = Unpack<GLuint,uint32_t>(ptr + 8 + 4);
6087 			GLuint var_width = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4);
6088 			GLuint var_height = Unpack<GLuint,uint32_t>(ptr + 8 + 4 + 4 + 4);
6089 			GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
6090 			if (useChecksum) {
6091 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4, checksumSize,
6092 					"gles1_decoder_context_t::decode, OP_glStartTilingQCOM: GL checksumCalculator failure\n");
6093 			}
6094 			#ifdef CHECK_GL_ERRORS
6095 			GLint err = this->glGetError();
6096 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glStartTilingQCOM\n", err);
6097 			#endif
6098 			DECODER_DEBUG_LOG("gles1(%p): glStartTilingQCOM(x:%u y:%u width:%u height:%u preserveMask:0x%08x )", stream, var_x, var_y, var_width, var_height, var_preserveMask);
6099 			this->glStartTilingQCOM(var_x, var_y, var_width, var_height, var_preserveMask);
6100 			SET_LASTCALL("glStartTilingQCOM");
6101 			android::base::endTrace();
6102 			break;
6103 		}
6104 		case OP_glEndTilingQCOM: {
6105 			android::base::beginTrace("glEndTilingQCOM decode");
6106 			GLbitfield var_preserveMask = Unpack<GLbitfield,uint32_t>(ptr + 8);
6107 			if (useChecksum) {
6108 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4, ptr + 8 + 4, checksumSize,
6109 					"gles1_decoder_context_t::decode, OP_glEndTilingQCOM: GL checksumCalculator failure\n");
6110 			}
6111 			#ifdef CHECK_GL_ERRORS
6112 			GLint err = this->glGetError();
6113 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glEndTilingQCOM\n", err);
6114 			#endif
6115 			DECODER_DEBUG_LOG("gles1(%p): glEndTilingQCOM(preserveMask:0x%08x )", stream, var_preserveMask);
6116 			this->glEndTilingQCOM(var_preserveMask);
6117 			SET_LASTCALL("glEndTilingQCOM");
6118 			android::base::endTrace();
6119 			break;
6120 		}
6121 		case OP_glGetGraphicsResetStatusEXT: {
6122 			android::base::beginTrace("glGetGraphicsResetStatusEXT decode");
6123 			if (useChecksum) {
6124 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8, ptr + 8, checksumSize,
6125 					"gles1_decoder_context_t::decode, OP_glGetGraphicsResetStatusEXT: GL checksumCalculator failure\n");
6126 			}
6127 			size_t totalTmpSize = sizeof(GLenum);
6128 			totalTmpSize += checksumSize;
6129 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6130 			#ifdef CHECK_GL_ERRORS
6131 			GLint err = this->glGetError();
6132 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glGetGraphicsResetStatusEXT\n", err);
6133 			#endif
6134 			DECODER_DEBUG_LOG("gles1(%p): glGetGraphicsResetStatusEXT()", stream);
6135 			*(GLenum *)(&tmpBuf[0]) = 			this->glGetGraphicsResetStatusEXT();
6136 			if (useChecksum) {
6137 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6138 			}
6139 			stream->flush();
6140 			SET_LASTCALL("glGetGraphicsResetStatusEXT");
6141 			android::base::endTrace();
6142 			break;
6143 		}
6144 		case OP_glReadnPixelsEXT: {
6145 			android::base::beginTrace("glReadnPixelsEXT decode");
6146 			GLint var_x = Unpack<GLint,uint32_t>(ptr + 8);
6147 			GLint var_y = Unpack<GLint,uint32_t>(ptr + 8 + 4);
6148 			GLsizei var_width = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4);
6149 			GLsizei var_height = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4);
6150 			GLenum var_format = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4);
6151 			GLenum var_type = Unpack<GLenum,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4);
6152 			GLsizei var_bufSize = Unpack<GLsizei,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4);
6153 			uint32_t size_data __attribute__((unused)) = Unpack<uint32_t,uint32_t>(ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4);
6154 			if (useChecksum) {
6155 				ChecksumCalculatorThreadInfo::validOrDie(checksumCalc, ptr, 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, ptr + 8 + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4, checksumSize,
6156 					"gles1_decoder_context_t::decode, OP_glReadnPixelsEXT: GL checksumCalculator failure\n");
6157 			}
6158 			size_t totalTmpSize = size_data;
6159 			totalTmpSize += checksumSize;
6160 			unsigned char *tmpBuf = stream->alloc(totalTmpSize);
6161 			OutputBuffer outptr_data(&tmpBuf[0], size_data);
6162 			#ifdef CHECK_GL_ERRORS
6163 			GLint err = this->glGetError();
6164 			if (err) fprintf(stderr, "gles1 Error (pre-call): 0x%X before glReadnPixelsEXT\n", err);
6165 			#endif
6166 			DECODER_DEBUG_LOG("gles1(%p): glReadnPixelsEXT(x:%d y:%d width:%d height:%d format:0x%08x type:0x%08x bufSize:%d data:%p(%u) )", stream, var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()), size_data);
6167 			this->glReadnPixelsEXT(var_x, var_y, var_width, var_height, var_format, var_type, var_bufSize, (GLvoid*)(outptr_data.get()));
6168 			outptr_data.flush();
6169 			if (useChecksum) {
6170 				ChecksumCalculatorThreadInfo::writeChecksum(checksumCalc, &tmpBuf[0], totalTmpSize - checksumSize, &tmpBuf[totalTmpSize - checksumSize], checksumSize);
6171 			}
6172 			stream->flush();
6173 			SET_LASTCALL("glReadnPixelsEXT");
6174 			android::base::endTrace();
6175 			break;
6176 		}
6177 		default:
6178 			return ptr - (unsigned char*)buf;
6179 		} //switch
6180 		#ifdef CHECK_GL_ERRORS
6181 		GLint err = this->glGetError();
6182 		if (err) fprintf(stderr, "gles1 Error (post-call): 0x%X in %s\n", err, lastCall);
6183 		#endif
6184 		ptr += packetLen;
6185 	} // while
6186 	return ptr - (unsigned char*)buf;
6187 }
6188 }  // namespace gfxstream
6189 
6190