/*
 * Copyright 2015, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * THIS FILE WAS GENERATED BY apic. DO NOT EDIT.
 */

#ifndef GAPII_GLES_SPY_H
#define GAPII_GLES_SPY_H

#include "gles_imports.h"
#include "gles_types.h"

#include "spy_base.h"

#include <gapic/log.h>

#include <memory>
#include <string>

namespace gapii {

class GlesSpy : public SpyBase {
public:
    inline void init(std::shared_ptr<gapic::Encoder> encoder);

    inline void replayCreateRenderer(uint32_t id);
    inline void replayBindRenderer(uint32_t id);
    inline void backbufferInfo(int32_t width, int32_t height, uint32_t color_fmt,
                               uint32_t depth_fmt, uint32_t stencil_fmt, bool resetViewportScissor);
    inline void startTimer(uint8_t index);
    inline uint64_t stopTimer(uint8_t index);
    inline void flushPostBuffer();
    inline int eglInitialize(void* dpy, int* major, int* minor);
    inline void* eglCreateContext(void* display, void* config, void* share_context,
                                  int* attrib_list);
    inline int eglMakeCurrent(void* display, void* draw, void* read, void* context);
    inline int eglSwapBuffers(void* display, void* surface);
    inline int eglQuerySurface(void* display, void* surface, int attribute, int* value);
    inline void* glXCreateContext(void* dpy, void* vis, void* shareList, bool direct);
    inline void* glXCreateNewContext(void* display, void* fbconfig, uint32_t type, void* shared,
                                     bool direct);
    inline void glXMakeContextCurrent(void* display, void* draw, void* read, void* ctx);
    inline void glXSwapBuffers(void* display, void* drawable);
    inline void* wglCreateContext(void* hdc);
    inline void* wglCreateContextAttribsARB(void* hdc, void* hShareContext, int* attribList);
    inline int wglMakeCurrent(void* hdc, void* hglrc);
    inline void wglSwapBuffers(void* hdc);
    inline int CGLCreateContext(void* pix, void* share, void** ctx);
    inline int CGLSetCurrentContext(void* ctx);
    inline void glEnableClientState(uint32_t type);
    inline void glDisableClientState(uint32_t type);
    inline void glGetProgramBinaryOES(uint32_t program, int32_t buffer_size, int32_t* bytes_written,
                                      uint32_t* binary_format, void* binary);
    inline void glProgramBinaryOES(uint32_t program, uint32_t binary_format, void* binary,
                                   int32_t binary_size);
    inline void glStartTilingQCOM(int32_t x, int32_t y, int32_t width, int32_t height,
                                  uint32_t preserveMask);
    inline void glEndTilingQCOM(uint32_t preserve_mask);
    inline void glDiscardFramebufferEXT(uint32_t target, int32_t numAttachments,
                                        uint32_t* attachments);
    inline void glInsertEventMarkerEXT(int32_t length, char* marker);
    inline void glPushGroupMarkerEXT(int32_t length, char* marker);
    inline void glPopGroupMarkerEXT();
    inline void glTexStorage1DEXT(uint32_t target, int32_t levels, uint32_t format, int32_t width);
    inline void glTexStorage2DEXT(uint32_t target, int32_t levels, uint32_t format, int32_t width,
                                  int32_t height);
    inline void glTexStorage3DEXT(uint32_t target, int32_t levels, uint32_t format, int32_t width,
                                  int32_t height, int32_t depth);
    inline void glTextureStorage1DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                      uint32_t format, int32_t width);
    inline void glTextureStorage2DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                      uint32_t format, int32_t width, int32_t height);
    inline void glTextureStorage3DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                      uint32_t format, int32_t width, int32_t height,
                                      int32_t depth);
    inline void glGenVertexArraysOES(int32_t count, uint32_t* arrays);
    inline void glBindVertexArrayOES(uint32_t array);
    inline void glDeleteVertexArraysOES(int32_t count, uint32_t* arrays);
    inline bool glIsVertexArrayOES(uint32_t array);
    inline void glEGLImageTargetTexture2DOES(uint32_t target, void* image);
    inline void glEGLImageTargetRenderbufferStorageOES(uint32_t target, void* image);
    inline uint32_t glGetGraphicsResetStatusEXT();
    inline void glBindAttribLocation(uint32_t program, uint32_t location, char* name);
    inline void glBlendFunc(uint32_t src_factor, uint32_t dst_factor);
    inline void glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb,
                                    uint32_t src_factor_alpha, uint32_t dst_factor_alpha);
    inline void glBlendEquation(uint32_t equation);
    inline void glBlendEquationSeparate(uint32_t rgb, uint32_t alpha);
    inline void glBlendColor(float red, float green, float blue, float alpha);
    inline void glEnableVertexAttribArray(uint32_t location);
    inline void glDisableVertexAttribArray(uint32_t location);
    inline void glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type,
                                      bool normalized, int32_t stride, void* data);
    inline void glGetActiveAttrib(uint32_t program, uint32_t location, int32_t buffer_size,
                                  int32_t* buffer_bytes_written, int32_t* vector_count,
                                  uint32_t* type, char* name);
    inline void glGetActiveUniform(uint32_t program, int32_t location, int32_t buffer_size,
                                   int32_t* buffer_bytes_written, int32_t* size, uint32_t* type,
                                   char* name);
    inline uint32_t glGetError();
    inline void glGetProgramiv(uint32_t program, uint32_t parameter, int32_t* value);
    inline void glGetShaderiv(uint32_t shader, uint32_t parameter, int32_t* value);
    inline int32_t glGetUniformLocation(uint32_t program, char* name);
    inline uint32_t glGetAttribLocation(uint32_t program, char* name);
    inline void glPixelStorei(uint32_t parameter, int32_t value);
    inline void glTexParameteri(uint32_t target, uint32_t parameter, int32_t value);
    inline void glTexParameterf(uint32_t target, uint32_t parameter, float value);
    inline void glGetTexParameteriv(uint32_t target, uint32_t parameter, int32_t* values);
    inline void glGetTexParameterfv(uint32_t target, uint32_t parameter, float* values);
    inline void glUniform1i(int32_t location, int32_t value);
    inline void glUniform2i(int32_t location, int32_t value0, int32_t value1);
    inline void glUniform3i(int32_t location, int32_t value0, int32_t value1, int32_t value2);
    inline void glUniform4i(int32_t location, int32_t value0, int32_t value1, int32_t value2,
                            int32_t value3);
    inline void glUniform1iv(int32_t location, int32_t count, int32_t* value);
    inline void glUniform2iv(int32_t location, int32_t count, int32_t* value);
    inline void glUniform3iv(int32_t location, int32_t count, int32_t* value);
    inline void glUniform4iv(int32_t location, int32_t count, int32_t* value);
    inline void glUniform1f(int32_t location, float value);
    inline void glUniform2f(int32_t location, float value0, float value1);
    inline void glUniform3f(int32_t location, float value0, float value1, float value2);
    inline void glUniform4f(int32_t location, float value0, float value1, float value2,
                            float value3);
    inline void glUniform1fv(int32_t location, int32_t count, float* value);
    inline void glUniform2fv(int32_t location, int32_t count, float* value);
    inline void glUniform3fv(int32_t location, int32_t count, float* value);
    inline void glUniform4fv(int32_t location, int32_t count, float* value);
    inline void glUniformMatrix2fv(int32_t location, int32_t count, bool transpose, float* values);
    inline void glUniformMatrix3fv(int32_t location, int32_t count, bool transpose, float* values);
    inline void glUniformMatrix4fv(int32_t location, int32_t count, bool transpose, float* values);
    inline void glGetUniformfv(uint32_t program, int32_t location, float* values);
    inline void glGetUniformiv(uint32_t program, int32_t location, int32_t* values);
    inline void glVertexAttrib1f(uint32_t location, float value0);
    inline void glVertexAttrib2f(uint32_t location, float value0, float value1);
    inline void glVertexAttrib3f(uint32_t location, float value0, float value1, float value2);
    inline void glVertexAttrib4f(uint32_t location, float value0, float value1, float value2,
                                 float value3);
    inline void glVertexAttrib1fv(uint32_t location, float* value);
    inline void glVertexAttrib2fv(uint32_t location, float* value);
    inline void glVertexAttrib3fv(uint32_t location, float* value);
    inline void glVertexAttrib4fv(uint32_t location, float* value);
    inline void glGetShaderPrecisionFormat(uint32_t shader_type, uint32_t precision_type,
                                           int32_t* range, int32_t* precision);
    inline void glDepthMask(bool enabled);
    inline void glDepthFunc(uint32_t function);
    inline void glDepthRangef(float near, float far);
    inline void glColorMask(bool red, bool green, bool blue, bool alpha);
    inline void glStencilMask(uint32_t mask);
    inline void glStencilMaskSeparate(uint32_t face, uint32_t mask);
    inline void glStencilFuncSeparate(uint32_t face, uint32_t function, int32_t reference_value,
                                      int32_t mask);
    inline void glStencilOpSeparate(uint32_t face, uint32_t stencil_fail,
                                    uint32_t stencil_pass_depth_fail,
                                    uint32_t stencil_pass_depth_pass);
    inline void glFrontFace(uint32_t orientation);
    inline void glViewport(int32_t x, int32_t y, int32_t width, int32_t height);
    inline void glScissor(int32_t x, int32_t y, int32_t width, int32_t height);
    inline void glActiveTexture(uint32_t unit);
    inline void glGenTextures(int32_t count, uint32_t* textures);
    inline void glDeleteTextures(int32_t count, uint32_t* textures);
    inline bool glIsTexture(uint32_t texture);
    inline void glBindTexture(uint32_t target, uint32_t texture);
    inline void glTexImage2D(uint32_t target, int32_t level, uint32_t internal_format,
                             int32_t width, int32_t height, int32_t border, uint32_t format,
                             uint32_t type, void* data);
    inline void glTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset, int32_t yoffset,
                                int32_t width, int32_t height, uint32_t format, uint32_t type,
                                void* data);
    inline void glCopyTexImage2D(uint32_t target, int32_t level, uint32_t format, int32_t x,
                                 int32_t y, int32_t width, int32_t height, int32_t border);
    inline void glCopyTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset,
                                    int32_t yoffset, int32_t x, int32_t y, int32_t width,
                                    int32_t height);
    inline void glCompressedTexImage2D(uint32_t target, int32_t level, uint32_t format,
                                       int32_t width, int32_t height, int32_t border,
                                       int32_t image_size, void* data);
    inline void glCompressedTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset,
                                          int32_t yoffset, int32_t width, int32_t height,
                                          uint32_t format, int32_t image_size, void* data);
    inline void glGenerateMipmap(uint32_t target);
    inline void glReadPixels(int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format,
                             uint32_t type, void* data);
    inline void glGenFramebuffers(int32_t count, uint32_t* framebuffers);
    inline void glBindFramebuffer(uint32_t target, uint32_t framebuffer);
    inline uint32_t glCheckFramebufferStatus(uint32_t target);
    inline void glDeleteFramebuffers(int32_t count, uint32_t* framebuffers);
    inline bool glIsFramebuffer(uint32_t framebuffer);
    inline void glGenRenderbuffers(int32_t count, uint32_t* renderbuffers);
    inline void glBindRenderbuffer(uint32_t target, uint32_t renderbuffer);
    inline void glRenderbufferStorage(uint32_t target, uint32_t format, int32_t width,
                                      int32_t height);
    inline void glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffers);
    inline bool glIsRenderbuffer(uint32_t renderbuffer);
    inline void glGetRenderbufferParameteriv(uint32_t target, uint32_t parameter, int32_t* values);
    inline void glGenBuffers(int32_t count, uint32_t* buffers);
    inline void glBindBuffer(uint32_t target, uint32_t buffer);
    inline void glBufferData(uint32_t target, int32_t size, void* data, uint32_t usage);
    inline void glBufferSubData(uint32_t target, int32_t offset, int32_t size, void* data);
    inline void glDeleteBuffers(int32_t count, uint32_t* buffers);
    inline bool glIsBuffer(uint32_t buffer);
    inline void glGetBufferParameteriv(uint32_t target, uint32_t parameter, int32_t* value);
    inline uint32_t glCreateShader(uint32_t type);
    inline void glDeleteShader(uint32_t shader);
    inline void glShaderSource(uint32_t shader, int32_t count, char** source, int32_t* length);
    inline void glShaderBinary(int32_t count, uint32_t* shaders, uint32_t binary_format,
                               void* binary, int32_t binary_size);
    inline void glGetShaderInfoLog(uint32_t shader, int32_t buffer_length,
                                   int32_t* string_length_written, char* info);
    inline void glGetShaderSource(uint32_t shader, int32_t buffer_length,
                                  int32_t* string_length_written, char* source);
    inline void glReleaseShaderCompiler();
    inline void glCompileShader(uint32_t shader);
    inline bool glIsShader(uint32_t shader);
    inline uint32_t glCreateProgram();
    inline void glDeleteProgram(uint32_t program);
    inline void glAttachShader(uint32_t program, uint32_t shader);
    inline void glDetachShader(uint32_t program, uint32_t shader);
    inline void glGetAttachedShaders(uint32_t program, int32_t buffer_length,
                                     int32_t* shaders_length_written, uint32_t* shaders);
    inline void glLinkProgram(uint32_t program);
    inline void glGetProgramInfoLog(uint32_t program, int32_t buffer_length,
                                    int32_t* string_length_written, char* info);
    inline void glUseProgram(uint32_t program);
    inline bool glIsProgram(uint32_t program);
    inline void glValidateProgram(uint32_t program);
    inline void glClearColor(float r, float g, float b, float a);
    inline void glClearDepthf(float depth);
    inline void glClearStencil(int32_t stencil);
    inline void glClear(uint32_t mask);
    inline void glCullFace(uint32_t mode);
    inline void glPolygonOffset(float scale_factor, float units);
    inline void glLineWidth(float width);
    inline void glSampleCoverage(float value, bool invert);
    inline void glHint(uint32_t target, uint32_t mode);
    inline void glFramebufferRenderbuffer(uint32_t framebuffer_target,
                                          uint32_t framebuffer_attachment,
                                          uint32_t renderbuffer_target, uint32_t renderbuffer);
    inline void glFramebufferTexture2D(uint32_t framebuffer_target, uint32_t framebuffer_attachment,
                                       uint32_t texture_target, uint32_t texture, int32_t level);
    inline void glGetFramebufferAttachmentParameteriv(uint32_t framebuffer_target,
                                                      uint32_t attachment, uint32_t parameter,
                                                      int32_t* value);
    inline void glDrawElements(uint32_t draw_mode, int32_t element_count, uint32_t indices_type,
                               void* indices);
    inline void glDrawArrays(uint32_t draw_mode, int32_t first_index, int32_t index_count);
    inline void glFlush();
    inline void glFinish();
    inline void glGetBooleanv(uint32_t param, bool* values);
    inline void glGetFloatv(uint32_t param, float* values);
    inline void glGetIntegerv(uint32_t param, int32_t* values);
    inline char* glGetString(uint32_t param);
    inline void glEnable(uint32_t capability);
    inline void glDisable(uint32_t capability);
    inline bool glIsEnabled(uint32_t capability);
    inline void* glMapBufferRange(uint32_t target, int32_t offset, int32_t length, uint32_t access);
    inline void glUnmapBuffer(uint32_t target);
    inline void glInvalidateFramebuffer(uint32_t target, int32_t count, uint32_t* attachments);
    inline void glRenderbufferStorageMultisample(uint32_t target, int32_t samples, uint32_t format,
                                                 int32_t width, int32_t height);
    inline void glBlitFramebuffer(int32_t srcX0, int32_t srcY0, int32_t srcX1, int32_t srcY1,
                                  int32_t dstX0, int32_t dstY0, int32_t dstX1, int32_t dstY1,
                                  uint32_t mask, uint32_t filter);
    inline void glGenQueries(int32_t count, uint32_t* queries);
    inline void glBeginQuery(uint32_t target, uint32_t query);
    inline void glEndQuery(uint32_t target);
    inline void glDeleteQueries(int32_t count, uint32_t* queries);
    inline bool glIsQuery(uint32_t query);
    inline void glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* value);
    inline void glGetQueryObjectuiv(uint32_t query, uint32_t parameter, uint32_t* value);
    inline void glGenQueriesEXT(int32_t count, uint32_t* queries);
    inline void glBeginQueryEXT(uint32_t target, uint32_t query);
    inline void glEndQueryEXT(uint32_t target);
    inline void glDeleteQueriesEXT(int32_t count, uint32_t* queries);
    inline bool glIsQueryEXT(uint32_t query);
    inline void glQueryCounterEXT(uint32_t query, uint32_t target);
    inline void glGetQueryivEXT(uint32_t target, uint32_t parameter, int32_t* value);
    inline void glGetQueryObjectivEXT(uint32_t query, uint32_t parameter, int32_t* value);
    inline void glGetQueryObjectuivEXT(uint32_t query, uint32_t parameter, uint32_t* value);
    inline void glGetQueryObjecti64vEXT(uint32_t query, uint32_t parameter, int64_t* value);
    inline void glGetQueryObjectui64vEXT(uint32_t query, uint32_t parameter, uint64_t* value);

protected:
    GlesImports mImports;

    // Globals
    ContextID NextContextID;
    ThreadID CurrentThread;
    ThreadIDToContextRef Contexts;
    EGLContextToContextRef EGLContexts;
    GLXContextToContextRef GLXContexts;
    HGLRCToContextRef WGLContexts;
    CGLContextObjToContextRef CGLContexts;

#include "gles_state_externs.inl"
};

// Inline methods
inline void GlesSpy::init(std::shared_ptr<gapic::Encoder> encoder) {
    SpyBase::init(encoder);
    mImports.Resolve();
}

inline void GlesSpy::replayCreateRenderer(uint32_t id) {
    GAPID_INFO("replayCreateRenderer()\n");

    do {
    } while (false);

    mEncoder->Uint16(0);  // Type ID -- TODO: mEncoder->Id(REPLAY_CREATE_RENDERER_ID);
    encodeObservations();
    mEncoder->Uint32(id);
}

inline void GlesSpy::replayBindRenderer(uint32_t id) {
    GAPID_INFO("replayBindRenderer()\n");

    do {
    } while (false);

    mEncoder->Uint16(1);  // Type ID -- TODO: mEncoder->Id(REPLAY_BIND_RENDERER_ID);
    encodeObservations();
    mEncoder->Uint32(id);
}

inline void GlesSpy::backbufferInfo(int32_t width, int32_t height, uint32_t color_fmt,
                                    uint32_t depth_fmt, uint32_t stencil_fmt,
                                    bool resetViewportScissor) {
    GAPID_INFO("backbufferInfo()\n");

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_0_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_0_result;
        std::shared_ptr<Framebuffer> l_backbuffer =
                l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)];
        RenderbufferId l_color_id = (RenderbufferId)(
                l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0].mObject);
        std::shared_ptr<Renderbuffer> l_color_buffer = l_ctx->mInstances.mRenderbuffers[l_color_id];
        RenderbufferId l_depth_id = (RenderbufferId)(
                l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT].mObject);
        std::shared_ptr<Renderbuffer> l_depth_buffer = l_ctx->mInstances.mRenderbuffers[l_depth_id];
        RenderbufferId l_stencil_id = (RenderbufferId)(
                l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT].mObject);
        std::shared_ptr<Renderbuffer> l_stencil_buffer =
                l_ctx->mInstances.mRenderbuffers[l_stencil_id];
        l_color_buffer->mWidth = width;
        l_color_buffer->mHeight = height;
        l_color_buffer->mFormat = color_fmt;
        l_depth_buffer->mWidth = width;
        l_depth_buffer->mHeight = height;
        l_depth_buffer->mFormat = depth_fmt;
        l_stencil_buffer->mWidth = width;
        l_stencil_buffer->mHeight = height;
        l_stencil_buffer->mFormat = stencil_fmt;
        if (resetViewportScissor) {
            l_ctx->mRasterizing.mScissor.mWidth = width;
            l_ctx->mRasterizing.mScissor.mHeight = height;
            l_ctx->mRasterizing.mViewport.mWidth = width;
            l_ctx->mRasterizing.mViewport.mHeight = height;
        }
    } while (false);

    mEncoder->Uint16(2);  // Type ID -- TODO: mEncoder->Id(BACKBUFFER_INFO_ID);
    encodeObservations();
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Uint32(static_cast<uint32_t>(color_fmt));
    mEncoder->Uint32(static_cast<uint32_t>(depth_fmt));
    mEncoder->Uint32(static_cast<uint32_t>(stencil_fmt));
    mEncoder->Bool(resetViewportScissor);
}

inline void GlesSpy::startTimer(uint8_t index) {
    GAPID_INFO("startTimer()\n");

    do {
    } while (false);

    mEncoder->Uint16(3);  // Type ID -- TODO: mEncoder->Id(START_TIMER_ID);
    encodeObservations();
    mEncoder->Uint8(index);
}

inline uint64_t GlesSpy::stopTimer(uint8_t index) {
    GAPID_INFO("stopTimer()\n");
    uint64_t result = 0;

    do {
        break;
    } while (false);

    mEncoder->Uint16(4);  // Type ID -- TODO: mEncoder->Id(STOP_TIMER_ID);
    encodeObservations();
    mEncoder->Uint8(index);
    mEncoder->Uint64(result);

    return result;
}

inline void GlesSpy::flushPostBuffer() {
    GAPID_INFO("flushPostBuffer()\n");

    do {
    } while (false);

    mEncoder->Uint16(5);  // Type ID -- TODO: mEncoder->Id(FLUSH_POST_BUFFER_ID);
    encodeObservations();
}

inline int GlesSpy::eglInitialize(void* dpy, int* major, int* minor) {
    GAPID_INFO("eglInitialize()\n");
    int result = mImports.eglInitialize(dpy, major, minor);

    do {
        write(slice(major, 0, 1), 0, read(slice(major, 0, 1), 0));
        write(slice(minor, 0, 1), 0, read(slice(minor, 0, 1), 0));
        break;
    } while (false);

    mEncoder->Uint16(6);  // Type ID -- TODO: mEncoder->Id(EGL_INITIALIZE_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(dpy));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(major));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(minor));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline void* GlesSpy::eglCreateContext(void* display, void* config, void* share_context,
                                       int* attrib_list) {
    GAPID_INFO("eglCreateContext()\n");
    void* result = mImports.eglCreateContext(display, config, share_context, attrib_list);

    do {
        EGLContext l_context = (EGLContext)(result);
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_1_result = l_ctx;
        this->EGLContexts[l_context] = l_CreateContext_1_result;
        break;
    } while (false);

    mEncoder->Uint16(7);  // Type ID -- TODO: mEncoder->Id(EGL_CREATE_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(config));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(share_context));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(attrib_list));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline int GlesSpy::eglMakeCurrent(void* display, void* draw, void* read, void* context) {
    GAPID_INFO("eglMakeCurrent()\n");
    int result = mImports.eglMakeCurrent(display, draw, read, context);

    do {
        std::shared_ptr<Context> l_SetContext_2_context = this->EGLContexts[context];
        this->Contexts[this->CurrentThread] = l_SetContext_2_context;
        break;
    } while (false);

    mEncoder->Uint16(8);  // Type ID -- TODO: mEncoder->Id(EGL_MAKE_CURRENT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(draw));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(read));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(context));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline int GlesSpy::eglSwapBuffers(void* display, void* surface) {
    GAPID_INFO("eglSwapBuffers()\n");
    int result = mImports.eglSwapBuffers(display, surface);

    do {
        break;
    } while (false);

    mEncoder->Uint16(9);  // Type ID -- TODO: mEncoder->Id(EGL_SWAP_BUFFERS_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(surface));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline int GlesSpy::eglQuerySurface(void* display, void* surface, int attribute, int* value) {
    GAPID_INFO("eglQuerySurface()\n");
    int result = mImports.eglQuerySurface(display, surface, attribute, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
        break;
    } while (false);

    mEncoder->Uint16(10);  // Type ID -- TODO: mEncoder->Id(EGL_QUERY_SURFACE_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(surface));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(attribute);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline void* GlesSpy::glXCreateContext(void* dpy, void* vis, void* shareList, bool direct) {
    GAPID_INFO("glXCreateContext()\n");
    void* result = mImports.glXCreateContext(dpy, vis, shareList, direct);

    do {
        GLXContext l_context = (GLXContext)(result);
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_3_result = l_ctx;
        this->GLXContexts[l_context] = l_CreateContext_3_result;
        break;
    } while (false);

    mEncoder->Uint16(11);  // Type ID -- TODO: mEncoder->Id(GL_X_CREATE_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(dpy));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(vis));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(shareList));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Bool(direct);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline void* GlesSpy::glXCreateNewContext(void* display, void* fbconfig, uint32_t type,
                                          void* shared, bool direct) {
    GAPID_INFO("glXCreateNewContext()\n");
    void* result = mImports.glXCreateNewContext(display, fbconfig, type, shared, direct);

    do {
        GLXContext l_context = (GLXContext)(result);
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_4_result = l_ctx;
        this->GLXContexts[l_context] = l_CreateContext_4_result;
        break;
    } while (false);

    mEncoder->Uint16(12);  // Type ID -- TODO: mEncoder->Id(GL_X_CREATE_NEW_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(fbconfig));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint32(type);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(shared));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Bool(direct);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline void GlesSpy::glXMakeContextCurrent(void* display, void* draw, void* read, void* ctx) {
    GAPID_INFO("glXMakeContextCurrent()\n");
    mImports.glXMakeContextCurrent(display, draw, read, ctx);

    do {
        std::shared_ptr<Context> l_SetContext_5_context = this->GLXContexts[ctx];
        this->Contexts[this->CurrentThread] = l_SetContext_5_context;
    } while (false);

    mEncoder->Uint16(13);  // Type ID -- TODO: mEncoder->Id(GL_X_MAKE_CONTEXT_CURRENT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(draw));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(read));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(ctx));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glXSwapBuffers(void* display, void* drawable) {
    GAPID_INFO("glXSwapBuffers()\n");
    mImports.glXSwapBuffers(display, drawable);

    do {
    } while (false);

    mEncoder->Uint16(14);  // Type ID -- TODO: mEncoder->Id(GL_X_SWAP_BUFFERS_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(display));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(drawable));
    mEncoder->Uint32(0);  // PoolID
}

inline void* GlesSpy::wglCreateContext(void* hdc) {
    GAPID_INFO("wglCreateContext()\n");
    void* result = mImports.wglCreateContext(hdc);

    do {
        HGLRC l_context = (HGLRC)(result);
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_6_result = l_ctx;
        this->WGLContexts[l_context] = l_CreateContext_6_result;
        break;
    } while (false);

    mEncoder->Uint16(15);  // Type ID -- TODO: mEncoder->Id(WGL_CREATE_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hdc));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline void* GlesSpy::wglCreateContextAttribsARB(void* hdc, void* hShareContext, int* attribList) {
    GAPID_INFO("wglCreateContextAttribsARB()\n");
    void* result = mImports.wglCreateContextAttribsARB(hdc, hShareContext, attribList);

    do {
        HGLRC l_context = (HGLRC)(result);
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_7_result = l_ctx;
        this->WGLContexts[l_context] = l_CreateContext_7_result;
        break;
    } while (false);

    mEncoder->Uint16(16);  // Type ID -- TODO: mEncoder->Id(WGL_CREATE_CONTEXT_ATTRIBS_A_R_B_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hdc));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hShareContext));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(attribList));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline int GlesSpy::wglMakeCurrent(void* hdc, void* hglrc) {
    GAPID_INFO("wglMakeCurrent()\n");
    int result = mImports.wglMakeCurrent(hdc, hglrc);

    do {
        std::shared_ptr<Context> l_SetContext_8_context = this->WGLContexts[hglrc];
        this->Contexts[this->CurrentThread] = l_SetContext_8_context;
        break;
    } while (false);

    mEncoder->Uint16(17);  // Type ID -- TODO: mEncoder->Id(WGL_MAKE_CURRENT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hdc));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hglrc));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline void GlesSpy::wglSwapBuffers(void* hdc) {
    GAPID_INFO("wglSwapBuffers()\n");
    mImports.wglSwapBuffers(hdc);

    do {
    } while (false);

    mEncoder->Uint16(18);  // Type ID -- TODO: mEncoder->Id(WGL_SWAP_BUFFERS_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(hdc));
    mEncoder->Uint32(0);  // PoolID
}

inline int GlesSpy::CGLCreateContext(void* pix, void* share, void** ctx) {
    GAPID_INFO("CGLCreateContext()\n");
    int result = mImports.CGLCreateContext(pix, share, ctx);

    do {
        CGLContextObj l_context = (CGLContextObj)(read(slice(ctx, 0, 1), 0));
        ContextID l_identifier = this->NextContextID;
        this->NextContextID = this->NextContextID + (ContextID)(1);
        std::shared_ptr<Context> l_ctx = std::shared_ptr<Context>((new Context()));
        l_ctx->mIdentifier = l_identifier;
        l_ctx->mInstances.mBuffers[(BufferId)(0)] = std::shared_ptr<Buffer>((new Buffer()));
        l_ctx->mInstances.mTextures[(TextureId)(0)] = std::shared_ptr<Texture>((new Texture()));
        l_ctx->mInstances.mRenderbuffers[(RenderbufferId)(0)] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        RenderbufferId l_color_id = (RenderbufferId)(4294967295);
        RenderbufferId l_depth_id = (RenderbufferId)(4294967294);
        RenderbufferId l_stencil_id = (RenderbufferId)(4294967293);
        l_ctx->mInstances.mRenderbuffers[l_color_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_depth_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        l_ctx->mInstances.mRenderbuffers[l_stencil_id] =
                std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        std::shared_ptr<Framebuffer> l_backbuffer =
                std::shared_ptr<Framebuffer>((new Framebuffer()));
        l_backbuffer->mAttachments[FramebufferAttachment::GL_COLOR_ATTACHMENT0] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_color_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_DEPTH_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_depth_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_backbuffer->mAttachments[FramebufferAttachment::GL_STENCIL_ATTACHMENT] =
                FramebufferAttachmentInfo()
                        .SetObject((uint32_t)(l_stencil_id))
                        .SetType(FramebufferAttachmentType::GL_RENDERBUFFER)
                        .SetCubeMapFace(CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X);
        l_ctx->mInstances.mFramebuffers[(FramebufferId)(0)] = l_backbuffer;
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = (FramebufferId)(0);
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = 4294967295;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = 4294967295;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT] = 4;
        l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT] = 4;
        for (int32_t l_i = 0; l_i < 64; ++l_i) {
            l_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)] =
                    std::shared_ptr<VertexAttributeArray>((new VertexAttributeArray()));
        }
        std::shared_ptr<Context> l_CreateContext_9_result = l_ctx;
        this->CGLContexts[l_context] = l_CreateContext_9_result;
        write(slice(ctx, 0, 1), 0, l_context);
        break;
    } while (false);

    mEncoder->Uint16(19);  // Type ID -- TODO: mEncoder->Id(C_G_L_CREATE_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(pix));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(share));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(ctx));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline int GlesSpy::CGLSetCurrentContext(void* ctx) {
    GAPID_INFO("CGLSetCurrentContext()\n");
    int result = mImports.CGLSetCurrentContext(ctx);

    do {
        std::shared_ptr<Context> l_SetContext_10_context = this->CGLContexts[ctx];
        this->Contexts[this->CurrentThread] = l_SetContext_10_context;
        break;
    } while (false);

    mEncoder->Uint16(20);  // Type ID -- TODO: mEncoder->Id(C_G_L_SET_CURRENT_CONTEXT_ID);
    encodeObservations();
    mEncoder->Uint64(reinterpret_cast<uint64_t>(ctx));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int64(result);

    return result;
}

inline void GlesSpy::glEnableClientState(uint32_t type) {
    GAPID_INFO("glEnableClientState()\n");
    mImports.glEnableClientState(type);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_11_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_11_result;
        l_ctx->mCapabilities[(uint32_t)(type)] = true;
    } while (false);

    mEncoder->Uint16(21);  // Type ID -- TODO: mEncoder->Id(GL_ENABLE_CLIENT_STATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(type));
}

inline void GlesSpy::glDisableClientState(uint32_t type) {
    GAPID_INFO("glDisableClientState()\n");
    mImports.glDisableClientState(type);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_12_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_12_result;
        l_ctx->mCapabilities[(uint32_t)(type)] = false;
    } while (false);

    mEncoder->Uint16(22);  // Type ID -- TODO: mEncoder->Id(GL_DISABLE_CLIENT_STATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(type));
}

inline void GlesSpy::glGetProgramBinaryOES(uint32_t program, int32_t buffer_size,
                                           int32_t* bytes_written, uint32_t* binary_format,
                                           void* binary) {
    GAPID_INFO("glGetProgramBinaryOES()\n");
    mImports.glGetProgramBinaryOES(program, buffer_size, bytes_written, binary_format, binary);

    do {
        int32_t l_l = (int32_t)(read(slice(bytes_written, 0, 1), 0));
        write(slice(bytes_written, 0, 1), 0, l_l);
        write(slice(binary_format, 0, 1), 0, read(slice(binary_format, 0, 1), 0));
        write(slice(binary, (uint64_t)(0), (uint64_t)(l_l)));
    } while (false);

    mEncoder->Uint16(23);  // Type ID -- TODO: mEncoder->Id(GL_GET_PROGRAM_BINARY_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(buffer_size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(bytes_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(binary_format));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(binary));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glProgramBinaryOES(uint32_t program, uint32_t binary_format, void* binary,
                                        int32_t binary_size) {
    GAPID_INFO("glProgramBinaryOES()\n");
    mImports.glProgramBinaryOES(program, binary_format, binary, binary_size);

    do {
    } while (false);

    mEncoder->Uint16(24);  // Type ID -- TODO: mEncoder->Id(GL_PROGRAM_BINARY_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(binary_format);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(binary));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int32(binary_size);
}

inline void GlesSpy::glStartTilingQCOM(int32_t x, int32_t y, int32_t width, int32_t height,
                                       uint32_t preserveMask) {
    GAPID_INFO("glStartTilingQCOM()\n");
    mImports.glStartTilingQCOM(x, y, width, height, preserveMask);

    do {
    } while (false);

    mEncoder->Uint16(25);  // Type ID -- TODO: mEncoder->Id(GL_START_TILING_Q_C_O_M_ID);
    encodeObservations();
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Uint32(static_cast<uint32_t>(preserveMask));
}

inline void GlesSpy::glEndTilingQCOM(uint32_t preserve_mask) {
    GAPID_INFO("glEndTilingQCOM()\n");
    mImports.glEndTilingQCOM(preserve_mask);

    do {
    } while (false);

    mEncoder->Uint16(26);  // Type ID -- TODO: mEncoder->Id(GL_END_TILING_Q_C_O_M_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(preserve_mask));
}

inline void GlesSpy::glDiscardFramebufferEXT(uint32_t target, int32_t numAttachments,
                                             uint32_t* attachments) {
    GAPID_INFO("glDiscardFramebufferEXT()\n");
    mImports.glDiscardFramebufferEXT(target, numAttachments, attachments);

    do {
    } while (false);

    mEncoder->Uint16(27);  // Type ID -- TODO: mEncoder->Id(GL_DISCARD_FRAMEBUFFER_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(numAttachments);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(attachments));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glInsertEventMarkerEXT(int32_t length, char* marker) {
    GAPID_INFO("glInsertEventMarkerEXT()\n");
    mImports.glInsertEventMarkerEXT(length, marker);

    do {
    } while (false);

    mEncoder->Uint16(28);  // Type ID -- TODO: mEncoder->Id(GL_INSERT_EVENT_MARKER_E_X_T_ID);
    encodeObservations();
    mEncoder->Int32(length);
    mEncoder->String(marker);
}

inline void GlesSpy::glPushGroupMarkerEXT(int32_t length, char* marker) {
    GAPID_INFO("glPushGroupMarkerEXT()\n");
    mImports.glPushGroupMarkerEXT(length, marker);

    do {
    } while (false);

    mEncoder->Uint16(29);  // Type ID -- TODO: mEncoder->Id(GL_PUSH_GROUP_MARKER_E_X_T_ID);
    encodeObservations();
    mEncoder->Int32(length);
    mEncoder->String(marker);
}

inline void GlesSpy::glPopGroupMarkerEXT() {
    GAPID_INFO("glPopGroupMarkerEXT()\n");
    mImports.glPopGroupMarkerEXT();

    do {
    } while (false);

    mEncoder->Uint16(30);  // Type ID -- TODO: mEncoder->Id(GL_POP_GROUP_MARKER_E_X_T_ID);
    encodeObservations();
}

inline void GlesSpy::glTexStorage1DEXT(uint32_t target, int32_t levels, uint32_t format,
                                       int32_t width) {
    GAPID_INFO("glTexStorage1DEXT()\n");
    mImports.glTexStorage1DEXT(target, levels, format, width);

    do {
    } while (false);

    mEncoder->Uint16(31);  // Type ID -- TODO: mEncoder->Id(GL_TEX_STORAGE1D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
}

inline void GlesSpy::glTexStorage2DEXT(uint32_t target, int32_t levels, uint32_t format,
                                       int32_t width, int32_t height) {
    GAPID_INFO("glTexStorage2DEXT()\n");
    mImports.glTexStorage2DEXT(target, levels, format, width, height);

    do {
    } while (false);

    mEncoder->Uint16(32);  // Type ID -- TODO: mEncoder->Id(GL_TEX_STORAGE2D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glTexStorage3DEXT(uint32_t target, int32_t levels, uint32_t format,
                                       int32_t width, int32_t height, int32_t depth) {
    GAPID_INFO("glTexStorage3DEXT()\n");
    mImports.glTexStorage3DEXT(target, levels, format, width, height, depth);

    do {
    } while (false);

    mEncoder->Uint16(33);  // Type ID -- TODO: mEncoder->Id(GL_TEX_STORAGE3D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Int32(depth);
}

inline void GlesSpy::glTextureStorage1DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                           uint32_t format, int32_t width) {
    GAPID_INFO("glTextureStorage1DEXT()\n");
    mImports.glTextureStorage1DEXT(texture, target, levels, format, width);

    do {
    } while (false);

    mEncoder->Uint16(34);  // Type ID -- TODO: mEncoder->Id(GL_TEXTURE_STORAGE1D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(texture);
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
}

inline void GlesSpy::glTextureStorage2DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                           uint32_t format, int32_t width, int32_t height) {
    GAPID_INFO("glTextureStorage2DEXT()\n");
    mImports.glTextureStorage2DEXT(texture, target, levels, format, width, height);

    do {
    } while (false);

    mEncoder->Uint16(35);  // Type ID -- TODO: mEncoder->Id(GL_TEXTURE_STORAGE2D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(texture);
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glTextureStorage3DEXT(uint32_t texture, uint32_t target, int32_t levels,
                                           uint32_t format, int32_t width, int32_t height,
                                           int32_t depth) {
    GAPID_INFO("glTextureStorage3DEXT()\n");
    mImports.glTextureStorage3DEXT(texture, target, levels, format, width, height, depth);

    do {
    } while (false);

    mEncoder->Uint16(36);  // Type ID -- TODO: mEncoder->Id(GL_TEXTURE_STORAGE3D_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(texture);
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(levels);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Int32(depth);
}

inline void GlesSpy::glGenVertexArraysOES(int32_t count, uint32_t* arrays) {
    GAPID_INFO("glGenVertexArraysOES()\n");
    mImports.glGenVertexArraysOES(count, arrays);

    do {
        Slice<VertexArrayId> l_a = slice(arrays, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_13_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_13_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            VertexArrayId l_id = (VertexArrayId)(
                    read(slice(arrays, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mVertexArrays[l_id] =
                    std::shared_ptr<VertexArray>((new VertexArray()));
            write(l_a, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(37);  // Type ID -- TODO: mEncoder->Id(GL_GEN_VERTEX_ARRAYS_O_E_S_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(arrays));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBindVertexArrayOES(uint32_t array) {
    GAPID_INFO("glBindVertexArrayOES()\n");
    mImports.glBindVertexArrayOES(array);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_14_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_14_result;
        if (!(l_ctx->mInstances.mVertexArrays.count(array) > 0)) {
            l_ctx->mInstances.mVertexArrays[array] =
                    std::shared_ptr<VertexArray>((new VertexArray()));
        }
        l_ctx->mBoundVertexArray = array;
    } while (false);

    mEncoder->Uint16(38);  // Type ID -- TODO: mEncoder->Id(GL_BIND_VERTEX_ARRAY_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(array);
}

inline void GlesSpy::glDeleteVertexArraysOES(int32_t count, uint32_t* arrays) {
    GAPID_INFO("glDeleteVertexArraysOES()\n");
    mImports.glDeleteVertexArraysOES(count, arrays);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_15_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_15_result;
        Slice<VertexArrayId> l_a = slice(arrays, (uint64_t)(0), (uint64_t)(count));
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mVertexArrays[read(l_a, (uint64_t)(l_i))] =
                    std::shared_ptr<VertexArray>();
        }
    } while (false);

    mEncoder->Uint16(39);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_VERTEX_ARRAYS_O_E_S_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(arrays));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsVertexArrayOES(uint32_t array) {
    GAPID_INFO("glIsVertexArrayOES()\n");
    bool result = mImports.glIsVertexArrayOES(array);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_16_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_16_result;
        break;
    } while (false);

    mEncoder->Uint16(40);  // Type ID -- TODO: mEncoder->Id(GL_IS_VERTEX_ARRAY_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(array);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glEGLImageTargetTexture2DOES(uint32_t target, void* image) {
    GAPID_INFO("glEGLImageTargetTexture2DOES()\n");
    mImports.glEGLImageTargetTexture2DOES(target, image);

    do {
    } while (false);

    mEncoder->Uint16(
            41);  // Type ID -- TODO: mEncoder->Id(GL_E_G_L_IMAGE_TARGET_TEXTURE2D_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(image));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glEGLImageTargetRenderbufferStorageOES(uint32_t target, void* image) {
    GAPID_INFO("glEGLImageTargetRenderbufferStorageOES()\n");
    mImports.glEGLImageTargetRenderbufferStorageOES(target, image);

    do {
    } while (false);

    mEncoder->Uint16(42);  // Type ID -- TODO:
                           // mEncoder->Id(GL_E_G_L_IMAGE_TARGET_RENDERBUFFER_STORAGE_O_E_S_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(image));
    mEncoder->Uint32(0);  // PoolID
}

inline uint32_t GlesSpy::glGetGraphicsResetStatusEXT() {
    GAPID_INFO("glGetGraphicsResetStatusEXT()\n");
    uint32_t result = mImports.glGetGraphicsResetStatusEXT();

    do {
        break;
    } while (false);

    mEncoder->Uint16(43);  // Type ID -- TODO: mEncoder->Id(GL_GET_GRAPHICS_RESET_STATUS_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(result));

    return result;
}

inline void GlesSpy::glBindAttribLocation(uint32_t program, uint32_t location, char* name) {
    GAPID_INFO("glBindAttribLocation()\n");
    mImports.glBindAttribLocation(program, location, name);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_17_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_17_result;
        std::shared_ptr<Program> l_p = l_ctx->mInstances.mPrograms[program];
        l_p->mAttributeBindings[name] = location;
    } while (false);

    mEncoder->Uint16(44);  // Type ID -- TODO: mEncoder->Id(GL_BIND_ATTRIB_LOCATION_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(location);
    mEncoder->String(name);
}

inline void GlesSpy::glBlendFunc(uint32_t src_factor, uint32_t dst_factor) {
    GAPID_INFO("glBlendFunc()\n");
    mImports.glBlendFunc(src_factor, dst_factor);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_18_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_18_result;
        l_ctx->mBlending.mSrcRgbBlendFactor = src_factor;
        l_ctx->mBlending.mSrcAlphaBlendFactor = src_factor;
        l_ctx->mBlending.mDstRgbBlendFactor = dst_factor;
        l_ctx->mBlending.mDstAlphaBlendFactor = dst_factor;
    } while (false);

    mEncoder->Uint16(45);  // Type ID -- TODO: mEncoder->Id(GL_BLEND_FUNC_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(src_factor));
    mEncoder->Uint32(static_cast<uint32_t>(dst_factor));
}

inline void GlesSpy::glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb,
                                         uint32_t src_factor_alpha, uint32_t dst_factor_alpha) {
    GAPID_INFO("glBlendFuncSeparate()\n");
    mImports.glBlendFuncSeparate(src_factor_rgb, dst_factor_rgb, src_factor_alpha,
                                 dst_factor_alpha);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_19_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_19_result;
        l_ctx->mBlending.mSrcRgbBlendFactor = src_factor_rgb;
        l_ctx->mBlending.mDstRgbBlendFactor = dst_factor_rgb;
        l_ctx->mBlending.mSrcAlphaBlendFactor = src_factor_alpha;
        l_ctx->mBlending.mDstAlphaBlendFactor = dst_factor_alpha;
    } while (false);

    mEncoder->Uint16(46);  // Type ID -- TODO: mEncoder->Id(GL_BLEND_FUNC_SEPARATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(src_factor_rgb));
    mEncoder->Uint32(static_cast<uint32_t>(dst_factor_rgb));
    mEncoder->Uint32(static_cast<uint32_t>(src_factor_alpha));
    mEncoder->Uint32(static_cast<uint32_t>(dst_factor_alpha));
}

inline void GlesSpy::glBlendEquation(uint32_t equation) {
    GAPID_INFO("glBlendEquation()\n");
    mImports.glBlendEquation(equation);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_20_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_20_result;
        l_ctx->mBlending.mBlendEquationRgb = equation;
        l_ctx->mBlending.mBlendEquationAlpha = equation;
    } while (false);

    mEncoder->Uint16(47);  // Type ID -- TODO: mEncoder->Id(GL_BLEND_EQUATION_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(equation));
}

inline void GlesSpy::glBlendEquationSeparate(uint32_t rgb, uint32_t alpha) {
    GAPID_INFO("glBlendEquationSeparate()\n");
    mImports.glBlendEquationSeparate(rgb, alpha);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_21_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_21_result;
        l_ctx->mBlending.mBlendEquationRgb = rgb;
        l_ctx->mBlending.mBlendEquationAlpha = alpha;
    } while (false);

    mEncoder->Uint16(48);  // Type ID -- TODO: mEncoder->Id(GL_BLEND_EQUATION_SEPARATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(rgb));
    mEncoder->Uint32(static_cast<uint32_t>(alpha));
}

inline void GlesSpy::glBlendColor(float red, float green, float blue, float alpha) {
    GAPID_INFO("glBlendColor()\n");
    mImports.glBlendColor(red, green, blue, alpha);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_22_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_22_result;
        l_ctx->mBlending.mBlendColor =
                Color().SetRed(red).SetGreen(green).SetBlue(blue).SetAlpha(alpha);
    } while (false);

    mEncoder->Uint16(49);  // Type ID -- TODO: mEncoder->Id(GL_BLEND_COLOR_ID);
    encodeObservations();
    mEncoder->Float32(red);
    mEncoder->Float32(green);
    mEncoder->Float32(blue);
    mEncoder->Float32(alpha);
}

inline void GlesSpy::glEnableVertexAttribArray(uint32_t location) {
    GAPID_INFO("glEnableVertexAttribArray()\n");
    mImports.glEnableVertexAttribArray(location);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_23_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_23_result;
        l_ctx->mVertexAttributeArrays[location]->mEnabled = true;
    } while (false);

    mEncoder->Uint16(50);  // Type ID -- TODO: mEncoder->Id(GL_ENABLE_VERTEX_ATTRIB_ARRAY_ID);
    encodeObservations();
    mEncoder->Uint32(location);
}

inline void GlesSpy::glDisableVertexAttribArray(uint32_t location) {
    GAPID_INFO("glDisableVertexAttribArray()\n");
    mImports.glDisableVertexAttribArray(location);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_24_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_24_result;
        l_ctx->mVertexAttributeArrays[location]->mEnabled = false;
    } while (false);

    mEncoder->Uint16(51);  // Type ID -- TODO: mEncoder->Id(GL_DISABLE_VERTEX_ATTRIB_ARRAY_ID);
    encodeObservations();
    mEncoder->Uint32(location);
}

inline void GlesSpy::glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type,
                                           bool normalized, int32_t stride, void* data) {
    GAPID_INFO("glVertexAttribPointer()\n");
    mImports.glVertexAttribPointer(location, size, type, normalized, stride, data);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_25_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_25_result;
        std::shared_ptr<VertexAttributeArray> l_a = l_ctx->mVertexAttributeArrays[location];
        l_a->mSize = (uint32_t)(size);
        l_a->mType = type;
        l_a->mNormalized = normalized;
        l_a->mStride = stride;
        l_a->mPointer = data;
        l_a->mBuffer = l_ctx->mBoundBuffers[BufferTarget::GL_ARRAY_BUFFER];
    } while (false);

    mEncoder->Uint16(52);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB_POINTER_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Int32(size);
    mEncoder->Uint32(static_cast<uint32_t>(type));
    mEncoder->Bool(normalized);
    mEncoder->Int32(stride);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetActiveAttrib(uint32_t program, uint32_t location, int32_t buffer_size,
                                       int32_t* buffer_bytes_written, int32_t* vector_count,
                                       uint32_t* type, char* name) {
    GAPID_INFO("glGetActiveAttrib()\n");
    mImports.glGetActiveAttrib(program, location, buffer_size, buffer_bytes_written, vector_count,
                               type, name);

    do {
    } while (false);

    mEncoder->Uint16(53);  // Type ID -- TODO: mEncoder->Id(GL_GET_ACTIVE_ATTRIB_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(location);
    mEncoder->Int32(buffer_size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(buffer_bytes_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(vector_count));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(type));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(name));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetActiveUniform(uint32_t program, int32_t location, int32_t buffer_size,
                                        int32_t* buffer_bytes_written, int32_t* size,
                                        uint32_t* type, char* name) {
    GAPID_INFO("glGetActiveUniform()\n");
    mImports.glGetActiveUniform(program, location, buffer_size, buffer_bytes_written, size, type,
                                name);

    do {
    } while (false);

    mEncoder->Uint16(54);  // Type ID -- TODO: mEncoder->Id(GL_GET_ACTIVE_UNIFORM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(location);
    mEncoder->Int32(buffer_size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(buffer_bytes_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(size));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(type));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(name));
    mEncoder->Uint32(0);  // PoolID
}

inline uint32_t GlesSpy::glGetError() {
    GAPID_INFO("glGetError()\n");
    uint32_t result = mImports.glGetError();

    do {
        break;
    } while (false);

    mEncoder->Uint16(55);  // Type ID -- TODO: mEncoder->Id(GL_GET_ERROR_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(result));

    return result;
}

inline void GlesSpy::glGetProgramiv(uint32_t program, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetProgramiv()\n");
    mImports.glGetProgramiv(program, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(56);  // Type ID -- TODO: mEncoder->Id(GL_GET_PROGRAMIV_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetShaderiv(uint32_t shader, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetShaderiv()\n");
    mImports.glGetShaderiv(shader, parameter, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_26_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_26_result;
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        write(slice(value, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case ShaderParameter::GL_SHADER_TYPE: */(((parameter) == (ShaderParameter::GL_SHADER_TYPE))) ? ((int32_t)(l_s->mType)) :
            /* case ShaderParameter::GL_DELETE_STATUS: */(((parameter) == (ShaderParameter::GL_DELETE_STATUS))) ? (/* clang-format off */
            /* switch(l_s->mDeletable) */
                /* case true: */(((l_s->mDeletable) == (true))) ? (1) :
                /* case false: */(((l_s->mDeletable) == (false))) ? (0) :
                /* default: */ 0 /* clang-format on */)
                              :
                              /* case ShaderParameter::GL_COMPILE_STATUS: */ (
                                      ((parameter) == (ShaderParameter::GL_COMPILE_STATUS)))
                                      ? (/* clang-format off */
            /* switch(l_s->mCompiled) */
                /* case true: */(((l_s->mCompiled) == (true))) ? (1) :
                /* case false: */(((l_s->mCompiled) == (false))) ? (0) :
                /* default: */ 0 /* clang-format on */)
                                      :
                                      /* case ShaderParameter::GL_INFO_LOG_LENGTH: */ ((
                                              (parameter) == (ShaderParameter::GL_INFO_LOG_LENGTH)))
                                              ? ((int32_t)(strlen(l_s->mInfoLog)))
                                              :
                                              /* case ShaderParameter::GL_SHADER_SOURCE_LENGTH: */ (
                                                      ((parameter) ==
                                                       (ShaderParameter::GL_SHADER_SOURCE_LENGTH)))
                                                      ? ((int32_t)(strlen(l_s->mSource)))
                                                      :
                                                      /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(57);  // Type ID -- TODO: mEncoder->Id(GL_GET_SHADERIV_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline int32_t GlesSpy::glGetUniformLocation(uint32_t program, char* name) {
    GAPID_INFO("glGetUniformLocation()\n");
    int32_t result = mImports.glGetUniformLocation(program, name);

    do {
        break;
    } while (false);

    mEncoder->Uint16(58);  // Type ID -- TODO: mEncoder->Id(GL_GET_UNIFORM_LOCATION_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->String(name);
    mEncoder->Int32(result);

    return result;
}

inline uint32_t GlesSpy::glGetAttribLocation(uint32_t program, char* name) {
    GAPID_INFO("glGetAttribLocation()\n");
    uint32_t result = mImports.glGetAttribLocation(program, name);

    do {
        break;
    } while (false);

    mEncoder->Uint16(59);  // Type ID -- TODO: mEncoder->Id(GL_GET_ATTRIB_LOCATION_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->String(name);
    mEncoder->Uint32(result);

    return result;
}

inline void GlesSpy::glPixelStorei(uint32_t parameter, int32_t value) {
    GAPID_INFO("glPixelStorei()\n");
    mImports.glPixelStorei(parameter, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_27_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_27_result;
        l_ctx->mPixelStorage[parameter] = value;
    } while (false);

    mEncoder->Uint16(60);  // Type ID -- TODO: mEncoder->Id(GL_PIXEL_STOREI_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Int32(value);
}

inline void GlesSpy::glTexParameteri(uint32_t target, uint32_t parameter, int32_t value) {
    GAPID_INFO("glTexParameteri()\n");
    mImports.glTexParameteri(target, parameter, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_28_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_28_result;
        TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit][target];
        std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
        switch (parameter) {
            case TextureParameter::GL_TEXTURE_MAG_FILTER: {
                l_t->mMagFilter = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_MIN_FILTER: {
                l_t->mMinFilter = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_WRAP_S: {
                l_t->mWrapS = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_WRAP_T: {
                l_t->mWrapT = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT: {
                l_t->mMaxAnisotropy = (float)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_R: {
                l_t->mSwizzleR = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_G: {
                l_t->mSwizzleG = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_B: {
                l_t->mSwizzleB = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_A: {
                l_t->mSwizzleA = (uint32_t)(value);
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(61);  // Type ID -- TODO: mEncoder->Id(GL_TEX_PARAMETERI_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Int32(value);
}

inline void GlesSpy::glTexParameterf(uint32_t target, uint32_t parameter, float value) {
    GAPID_INFO("glTexParameterf()\n");
    mImports.glTexParameterf(target, parameter, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_29_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_29_result;
        TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit][target];
        std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
        switch (parameter) {
            case TextureParameter::GL_TEXTURE_MAG_FILTER: {
                l_t->mMagFilter = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_MIN_FILTER: {
                l_t->mMinFilter = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_WRAP_S: {
                l_t->mWrapS = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_WRAP_T: {
                l_t->mWrapT = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT: {
                l_t->mMaxAnisotropy = value;
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_R: {
                l_t->mSwizzleR = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_G: {
                l_t->mSwizzleG = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_B: {
                l_t->mSwizzleB = (uint32_t)(value);
                break;
            }
            case TextureParameter::GL_TEXTURE_SWIZZLE_A: {
                l_t->mSwizzleA = (uint32_t)(value);
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(62);  // Type ID -- TODO: mEncoder->Id(GL_TEX_PARAMETERF_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Float32(value);
}

inline void GlesSpy::glGetTexParameteriv(uint32_t target, uint32_t parameter, int32_t* values) {
    GAPID_INFO("glGetTexParameteriv()\n");
    mImports.glGetTexParameteriv(target, parameter, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_30_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_30_result;
        TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit][target];
        std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
        write(slice(values, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case TextureParameter::GL_TEXTURE_MAG_FILTER: */(((parameter) == (TextureParameter::GL_TEXTURE_MAG_FILTER))) ? ((int32_t)(l_t->mMagFilter)) :
            /* case TextureParameter::GL_TEXTURE_MIN_FILTER: */(((parameter) == (TextureParameter::GL_TEXTURE_MIN_FILTER))) ? ((int32_t)(l_t->mMinFilter)) :
            /* case TextureParameter::GL_TEXTURE_WRAP_S: */(((parameter) == (TextureParameter::GL_TEXTURE_WRAP_S))) ? ((int32_t)(l_t->mWrapS)) :
            /* case TextureParameter::GL_TEXTURE_WRAP_T: */(((parameter) == (TextureParameter::GL_TEXTURE_WRAP_T))) ? ((int32_t)(l_t->mWrapT)) :
            /* case TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT: */(((parameter) == (TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT))) ? ((int32_t)(l_t->mMaxAnisotropy)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_R: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_R))) ? ((int32_t)(l_t->mSwizzleR)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_G: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_G))) ? ((int32_t)(l_t->mSwizzleG)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_B: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_B))) ? ((int32_t)(l_t->mSwizzleB)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_A: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_A))) ? ((int32_t)(l_t->mSwizzleA)) :
            /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(63);  // Type ID -- TODO: mEncoder->Id(GL_GET_TEX_PARAMETERIV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetTexParameterfv(uint32_t target, uint32_t parameter, float* values) {
    GAPID_INFO("glGetTexParameterfv()\n");
    mImports.glGetTexParameterfv(target, parameter, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_31_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_31_result;
        TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit][target];
        std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
        write(slice(values, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case TextureParameter::GL_TEXTURE_MAG_FILTER: */(((parameter) == (TextureParameter::GL_TEXTURE_MAG_FILTER))) ? ((float)(l_t->mMagFilter)) :
            /* case TextureParameter::GL_TEXTURE_MIN_FILTER: */(((parameter) == (TextureParameter::GL_TEXTURE_MIN_FILTER))) ? ((float)(l_t->mMinFilter)) :
            /* case TextureParameter::GL_TEXTURE_WRAP_S: */(((parameter) == (TextureParameter::GL_TEXTURE_WRAP_S))) ? ((float)(l_t->mWrapS)) :
            /* case TextureParameter::GL_TEXTURE_WRAP_T: */(((parameter) == (TextureParameter::GL_TEXTURE_WRAP_T))) ? ((float)(l_t->mWrapT)) :
            /* case TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT: */(((parameter) == (TextureParameter::GL_TEXTURE_MAX_ANISOTROPY_EXT))) ? (l_t->mMaxAnisotropy) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_R: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_R))) ? ((float)(l_t->mSwizzleR)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_G: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_G))) ? ((float)(l_t->mSwizzleG)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_B: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_B))) ? ((float)(l_t->mSwizzleB)) :
            /* case TextureParameter::GL_TEXTURE_SWIZZLE_A: */(((parameter) == (TextureParameter::GL_TEXTURE_SWIZZLE_A))) ? ((float)(l_t->mSwizzleA)) :
            /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(64);  // Type ID -- TODO: mEncoder->Id(GL_GET_TEX_PARAMETERFV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform1i(int32_t location, int32_t value) {
    GAPID_INFO("glUniform1i()\n");
    mImports.glUniform1i(location, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_32_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_32_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT;
        l_uniform.mValue.mS32 = value;
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(65);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM1I_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(value);
}

inline void GlesSpy::glUniform2i(int32_t location, int32_t value0, int32_t value1) {
    GAPID_INFO("glUniform2i()\n");
    mImports.glUniform2i(location, value0, value1);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_33_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_33_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC2;
        l_uniform.mValue.mVec2i = Vec2i().SetX(value0).SetY(value1);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(66);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM2I_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(value0);
    mEncoder->Int32(value1);
}

inline void GlesSpy::glUniform3i(int32_t location, int32_t value0, int32_t value1, int32_t value2) {
    GAPID_INFO("glUniform3i()\n");
    mImports.glUniform3i(location, value0, value1, value2);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_34_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_34_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC3;
        l_uniform.mValue.mVec3i = Vec3i().SetX(value0).SetY(value1).SetZ(value2);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(67);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM3I_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(value0);
    mEncoder->Int32(value1);
    mEncoder->Int32(value2);
}

inline void GlesSpy::glUniform4i(int32_t location, int32_t value0, int32_t value1, int32_t value2,
                                 int32_t value3) {
    GAPID_INFO("glUniform4i()\n");
    mImports.glUniform4i(location, value0, value1, value2, value3);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_35_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_35_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC4;
        l_uniform.mValue.mVec4i = Vec4i().SetX(value0).SetY(value1).SetZ(value2).SetW(value3);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(68);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM4I_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(value0);
    mEncoder->Int32(value1);
    mEncoder->Int32(value2);
    mEncoder->Int32(value3);
}

inline void GlesSpy::glUniform1iv(int32_t location, int32_t count, int32_t* value) {
    GAPID_INFO("glUniform1iv()\n");
    mImports.glUniform1iv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_36_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_36_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT;
        l_uniform.mValue.mS32 = read(slice(value, 0, 1), 0);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(69);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM1IV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform2iv(int32_t location, int32_t count, int32_t* value) {
    GAPID_INFO("glUniform2iv()\n");
    mImports.glUniform2iv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_37_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_37_result;
        Slice<int32_t> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 2));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC2;
        l_uniform.mValue.mVec2i = Vec2i().SetX(read(l_v, 0)).SetY(read(l_v, 1));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(70);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM2IV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform3iv(int32_t location, int32_t count, int32_t* value) {
    GAPID_INFO("glUniform3iv()\n");
    mImports.glUniform3iv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_38_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_38_result;
        Slice<int32_t> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 3));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC3;
        l_uniform.mValue.mVec3i = Vec3i().SetX(read(l_v, 0)).SetY(read(l_v, 1)).SetZ(read(l_v, 2));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(71);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM3IV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform4iv(int32_t location, int32_t count, int32_t* value) {
    GAPID_INFO("glUniform4iv()\n");
    mImports.glUniform4iv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_39_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_39_result;
        Slice<int32_t> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 4));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_INT_VEC4;
        l_uniform.mValue.mVec4i =
                Vec4i().SetX(read(l_v, 0)).SetY(read(l_v, 1)).SetZ(read(l_v, 2)).SetW(read(l_v, 3));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(72);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM4IV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform1f(int32_t location, float value) {
    GAPID_INFO("glUniform1f()\n");
    mImports.glUniform1f(location, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_40_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_40_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT;
        l_uniform.mValue.mF32 = value;
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(73);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM1F_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Float32(value);
}

inline void GlesSpy::glUniform2f(int32_t location, float value0, float value1) {
    GAPID_INFO("glUniform2f()\n");
    mImports.glUniform2f(location, value0, value1);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_41_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_41_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC2;
        l_uniform.mValue.mVec2f = Vec2f().SetX(value0).SetY(value1);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(74);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM2F_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
}

inline void GlesSpy::glUniform3f(int32_t location, float value0, float value1, float value2) {
    GAPID_INFO("glUniform3f()\n");
    mImports.glUniform3f(location, value0, value1, value2);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_42_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_42_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC3;
        l_uniform.mValue.mVec3f = Vec3f().SetX(value0).SetY(value1).SetZ(value2);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(75);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM3F_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
    mEncoder->Float32(value2);
}

inline void GlesSpy::glUniform4f(int32_t location, float value0, float value1, float value2,
                                 float value3) {
    GAPID_INFO("glUniform4f()\n");
    mImports.glUniform4f(location, value0, value1, value2, value3);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_43_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_43_result;
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC4;
        l_uniform.mValue.mVec4f = Vec4f().SetX(value0).SetY(value1).SetZ(value2).SetW(value3);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(76);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM4F_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
    mEncoder->Float32(value2);
    mEncoder->Float32(value3);
}

inline void GlesSpy::glUniform1fv(int32_t location, int32_t count, float* value) {
    GAPID_INFO("glUniform1fv()\n");
    mImports.glUniform1fv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_44_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_44_result;
        Slice<float> l_v = slice(value, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT;
        l_uniform.mValue.mF32 = read(l_v, 0);
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(77);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM1FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform2fv(int32_t location, int32_t count, float* value) {
    GAPID_INFO("glUniform2fv()\n");
    mImports.glUniform2fv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_45_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_45_result;
        Slice<float> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 2));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC2;
        l_uniform.mValue.mVec2f = Vec2f().SetX(read(l_v, 0)).SetY(read(l_v, 1));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(78);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM2FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform3fv(int32_t location, int32_t count, float* value) {
    GAPID_INFO("glUniform3fv()\n");
    mImports.glUniform3fv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_46_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_46_result;
        Slice<float> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 3));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC3;
        l_uniform.mValue.mVec3f = Vec3f().SetX(read(l_v, 0)).SetY(read(l_v, 1)).SetZ(read(l_v, 2));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(79);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM3FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniform4fv(int32_t location, int32_t count, float* value) {
    GAPID_INFO("glUniform4fv()\n");
    mImports.glUniform4fv(location, count, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_47_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_47_result;
        Slice<float> l_v = slice(value, (uint64_t)(0), (uint64_t)(count * 4));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_VEC4;
        l_uniform.mValue.mVec4f =
                Vec4f().SetX(read(l_v, 0)).SetY(read(l_v, 1)).SetZ(read(l_v, 2)).SetW(read(l_v, 3));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(80);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM4FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniformMatrix2fv(int32_t location, int32_t count, bool transpose,
                                        float* values) {
    GAPID_INFO("glUniformMatrix2fv()\n");
    mImports.glUniformMatrix2fv(location, count, transpose, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_48_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_48_result;
        Slice<float> l_v = slice(values, (uint64_t)(0), (uint64_t)(count * 4));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_MAT2;
        l_uniform.mValue.mMat2f = Mat2f()
                                          .SetCol0(Vec2f().SetX(read(l_v, 0)).SetY(read(l_v, 1)))
                                          .SetCol1(Vec2f().SetX(read(l_v, 3)).SetY(read(l_v, 4)));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(81);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM_MATRIX2FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Bool(transpose);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniformMatrix3fv(int32_t location, int32_t count, bool transpose,
                                        float* values) {
    GAPID_INFO("glUniformMatrix3fv()\n");
    mImports.glUniformMatrix3fv(location, count, transpose, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_49_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_49_result;
        Slice<float> l_v = slice(values, (uint64_t)(0), (uint64_t)(count * 9));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mType = ShaderUniformType::GL_FLOAT_MAT3;
        l_uniform.mValue.mMat3f =
                Mat3f()
                        .SetCol0(Vec3f().SetX(read(l_v, 0)).SetY(read(l_v, 1)).SetZ(read(l_v, 2)))
                        .SetCol1(Vec3f().SetX(read(l_v, 3)).SetY(read(l_v, 4)).SetZ(read(l_v, 5)))
                        .SetCol2(Vec3f().SetX(read(l_v, 6)).SetY(read(l_v, 7)).SetZ(read(l_v, 8)));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(82);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM_MATRIX3FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Bool(transpose);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUniformMatrix4fv(int32_t location, int32_t count, bool transpose,
                                        float* values) {
    GAPID_INFO("glUniformMatrix4fv()\n");
    mImports.glUniformMatrix4fv(location, count, transpose, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_50_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_50_result;
        Slice<float> l_v = slice(values, (uint64_t)(0), (uint64_t)(count * 16));
        std::shared_ptr<Program> l_program = l_ctx->mInstances.mPrograms[l_ctx->mBoundProgram];
        Uniform l_uniform = l_program->mUniforms[location];
        l_uniform.mValue.mMat4f =
                Mat4f()
                        .SetCol0(Vec4f()
                                         .SetX(read(l_v, 0))
                                         .SetY(read(l_v, 1))
                                         .SetZ(read(l_v, 2))
                                         .SetW(read(l_v, 3)))
                        .SetCol1(Vec4f()
                                         .SetX(read(l_v, 4))
                                         .SetY(read(l_v, 5))
                                         .SetZ(read(l_v, 6))
                                         .SetW(read(l_v, 7)))
                        .SetCol2(Vec4f()
                                         .SetX(read(l_v, 8))
                                         .SetY(read(l_v, 9))
                                         .SetZ(read(l_v, 10))
                                         .SetW(read(l_v, 11)))
                        .SetCol3(Vec4f()
                                         .SetX(read(l_v, 12))
                                         .SetY(read(l_v, 13))
                                         .SetZ(read(l_v, 14))
                                         .SetW(read(l_v, 15)));
        l_program->mUniforms[location] = l_uniform;
    } while (false);

    mEncoder->Uint16(83);  // Type ID -- TODO: mEncoder->Id(GL_UNIFORM_MATRIX4FV_ID);
    encodeObservations();
    mEncoder->Int32(location);
    mEncoder->Int32(count);
    mEncoder->Bool(transpose);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetUniformfv(uint32_t program, int32_t location, float* values) {
    GAPID_INFO("glGetUniformfv()\n");
    mImports.glGetUniformfv(program, location, values);

    do {
    } while (false);

    mEncoder->Uint16(84);  // Type ID -- TODO: mEncoder->Id(GL_GET_UNIFORMFV_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetUniformiv(uint32_t program, int32_t location, int32_t* values) {
    GAPID_INFO("glGetUniformiv()\n");
    mImports.glGetUniformiv(program, location, values);

    do {
    } while (false);

    mEncoder->Uint16(85);  // Type ID -- TODO: mEncoder->Id(GL_GET_UNIFORMIV_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glVertexAttrib1f(uint32_t location, float value0) {
    GAPID_INFO("glVertexAttrib1f()\n");
    mImports.glVertexAttrib1f(location, value0);

    do {
    } while (false);

    mEncoder->Uint16(86);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB1F_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Float32(value0);
}

inline void GlesSpy::glVertexAttrib2f(uint32_t location, float value0, float value1) {
    GAPID_INFO("glVertexAttrib2f()\n");
    mImports.glVertexAttrib2f(location, value0, value1);

    do {
    } while (false);

    mEncoder->Uint16(87);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB2F_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
}

inline void GlesSpy::glVertexAttrib3f(uint32_t location, float value0, float value1, float value2) {
    GAPID_INFO("glVertexAttrib3f()\n");
    mImports.glVertexAttrib3f(location, value0, value1, value2);

    do {
    } while (false);

    mEncoder->Uint16(88);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB3F_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
    mEncoder->Float32(value2);
}

inline void GlesSpy::glVertexAttrib4f(uint32_t location, float value0, float value1, float value2,
                                      float value3) {
    GAPID_INFO("glVertexAttrib4f()\n");
    mImports.glVertexAttrib4f(location, value0, value1, value2, value3);

    do {
    } while (false);

    mEncoder->Uint16(89);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB4F_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Float32(value0);
    mEncoder->Float32(value1);
    mEncoder->Float32(value2);
    mEncoder->Float32(value3);
}

inline void GlesSpy::glVertexAttrib1fv(uint32_t location, float* value) {
    GAPID_INFO("glVertexAttrib1fv()\n");
    mImports.glVertexAttrib1fv(location, value);

    do {
        read(slice(value, 0, 1));
    } while (false);

    mEncoder->Uint16(90);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB1FV_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glVertexAttrib2fv(uint32_t location, float* value) {
    GAPID_INFO("glVertexAttrib2fv()\n");
    mImports.glVertexAttrib2fv(location, value);

    do {
        read(slice(value, 0, 2));
    } while (false);

    mEncoder->Uint16(91);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB2FV_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glVertexAttrib3fv(uint32_t location, float* value) {
    GAPID_INFO("glVertexAttrib3fv()\n");
    mImports.glVertexAttrib3fv(location, value);

    do {
        read(slice(value, 0, 3));
    } while (false);

    mEncoder->Uint16(92);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB3FV_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glVertexAttrib4fv(uint32_t location, float* value) {
    GAPID_INFO("glVertexAttrib4fv()\n");
    mImports.glVertexAttrib4fv(location, value);

    do {
        read(slice(value, 0, 4));
    } while (false);

    mEncoder->Uint16(93);  // Type ID -- TODO: mEncoder->Id(GL_VERTEX_ATTRIB4FV_ID);
    encodeObservations();
    mEncoder->Uint32(location);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetShaderPrecisionFormat(uint32_t shader_type, uint32_t precision_type,
                                                int32_t* range, int32_t* precision) {
    GAPID_INFO("glGetShaderPrecisionFormat()\n");
    mImports.glGetShaderPrecisionFormat(shader_type, precision_type, range, precision);

    do {
        write(slice(range, 0, 2));
        write(slice(precision, 0, 1), 0, read(slice(precision, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(94);  // Type ID -- TODO: mEncoder->Id(GL_GET_SHADER_PRECISION_FORMAT_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(shader_type));
    mEncoder->Uint32(static_cast<uint32_t>(precision_type));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(range));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(precision));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glDepthMask(bool enabled) {
    GAPID_INFO("glDepthMask()\n");
    mImports.glDepthMask(enabled);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_51_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_51_result;
        l_ctx->mRasterizing.mDepthMask = enabled;
    } while (false);

    mEncoder->Uint16(95);  // Type ID -- TODO: mEncoder->Id(GL_DEPTH_MASK_ID);
    encodeObservations();
    mEncoder->Bool(enabled);
}

inline void GlesSpy::glDepthFunc(uint32_t function) {
    GAPID_INFO("glDepthFunc()\n");
    mImports.glDepthFunc(function);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_52_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_52_result;
        l_ctx->mRasterizing.mDepthTestFunction = function;
    } while (false);

    mEncoder->Uint16(96);  // Type ID -- TODO: mEncoder->Id(GL_DEPTH_FUNC_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(function));
}

inline void GlesSpy::glDepthRangef(float near, float far) {
    GAPID_INFO("glDepthRangef()\n");
    mImports.glDepthRangef(near, far);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_53_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_53_result;
        l_ctx->mRasterizing.mDepthNear = near;
        l_ctx->mRasterizing.mDepthFar = far;
    } while (false);

    mEncoder->Uint16(97);  // Type ID -- TODO: mEncoder->Id(GL_DEPTH_RANGEF_ID);
    encodeObservations();
    mEncoder->Float32(near);
    mEncoder->Float32(far);
}

inline void GlesSpy::glColorMask(bool red, bool green, bool blue, bool alpha) {
    GAPID_INFO("glColorMask()\n");
    mImports.glColorMask(red, green, blue, alpha);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_54_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_54_result;
        l_ctx->mRasterizing.mColorMaskRed = red;
        l_ctx->mRasterizing.mColorMaskGreen = green;
        l_ctx->mRasterizing.mColorMaskBlue = blue;
        l_ctx->mRasterizing.mColorMaskAlpha = alpha;
    } while (false);

    mEncoder->Uint16(98);  // Type ID -- TODO: mEncoder->Id(GL_COLOR_MASK_ID);
    encodeObservations();
    mEncoder->Bool(red);
    mEncoder->Bool(green);
    mEncoder->Bool(blue);
    mEncoder->Bool(alpha);
}

inline void GlesSpy::glStencilMask(uint32_t mask) {
    GAPID_INFO("glStencilMask()\n");
    mImports.glStencilMask(mask);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_55_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_55_result;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = mask;
        l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = mask;
    } while (false);

    mEncoder->Uint16(99);  // Type ID -- TODO: mEncoder->Id(GL_STENCIL_MASK_ID);
    encodeObservations();
    mEncoder->Uint32(mask);
}

inline void GlesSpy::glStencilMaskSeparate(uint32_t face, uint32_t mask) {
    GAPID_INFO("glStencilMaskSeparate()\n");
    mImports.glStencilMaskSeparate(face, mask);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_56_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_56_result;
        switch (face) {
            case FaceMode::GL_FRONT: {
                l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = mask;
                break;
            }
            case FaceMode::GL_BACK: {
                l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = mask;
                break;
            }
            case FaceMode::GL_FRONT_AND_BACK: {
                l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT] = mask;
                l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK] = mask;
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(100);  // Type ID -- TODO: mEncoder->Id(GL_STENCIL_MASK_SEPARATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(face));
    mEncoder->Uint32(mask);
}

inline void GlesSpy::glStencilFuncSeparate(uint32_t face, uint32_t function,
                                           int32_t reference_value, int32_t mask) {
    GAPID_INFO("glStencilFuncSeparate()\n");
    mImports.glStencilFuncSeparate(face, function, reference_value, mask);

    do {
    } while (false);

    mEncoder->Uint16(101);  // Type ID -- TODO: mEncoder->Id(GL_STENCIL_FUNC_SEPARATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(face));
    mEncoder->Uint32(static_cast<uint32_t>(function));
    mEncoder->Int32(reference_value);
    mEncoder->Int32(mask);
}

inline void GlesSpy::glStencilOpSeparate(uint32_t face, uint32_t stencil_fail,
                                         uint32_t stencil_pass_depth_fail,
                                         uint32_t stencil_pass_depth_pass) {
    GAPID_INFO("glStencilOpSeparate()\n");
    mImports.glStencilOpSeparate(face, stencil_fail, stencil_pass_depth_fail,
                                 stencil_pass_depth_pass);

    do {
    } while (false);

    mEncoder->Uint16(102);  // Type ID -- TODO: mEncoder->Id(GL_STENCIL_OP_SEPARATE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(face));
    mEncoder->Uint32(static_cast<uint32_t>(stencil_fail));
    mEncoder->Uint32(static_cast<uint32_t>(stencil_pass_depth_fail));
    mEncoder->Uint32(static_cast<uint32_t>(stencil_pass_depth_pass));
}

inline void GlesSpy::glFrontFace(uint32_t orientation) {
    GAPID_INFO("glFrontFace()\n");
    mImports.glFrontFace(orientation);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_57_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_57_result;
        l_ctx->mRasterizing.mFrontFace = orientation;
    } while (false);

    mEncoder->Uint16(103);  // Type ID -- TODO: mEncoder->Id(GL_FRONT_FACE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(orientation));
}

inline void GlesSpy::glViewport(int32_t x, int32_t y, int32_t width, int32_t height) {
    GAPID_INFO("glViewport()\n");
    mImports.glViewport(x, y, width, height);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_58_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_58_result;
        l_ctx->mRasterizing.mViewport = Rect().SetX(x).SetY(y).SetWidth(width).SetHeight(height);
    } while (false);

    mEncoder->Uint16(104);  // Type ID -- TODO: mEncoder->Id(GL_VIEWPORT_ID);
    encodeObservations();
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glScissor(int32_t x, int32_t y, int32_t width, int32_t height) {
    GAPID_INFO("glScissor()\n");
    mImports.glScissor(x, y, width, height);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_59_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_59_result;
        l_ctx->mRasterizing.mScissor = Rect().SetX(x).SetY(y).SetWidth(width).SetHeight(height);
    } while (false);

    mEncoder->Uint16(105);  // Type ID -- TODO: mEncoder->Id(GL_SCISSOR_ID);
    encodeObservations();
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glActiveTexture(uint32_t unit) {
    GAPID_INFO("glActiveTexture()\n");
    mImports.glActiveTexture(unit);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_60_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_60_result;
        l_ctx->mActiveTextureUnit = unit;
        if (!(l_ctx->mTextureUnits.count(unit) > 0)) {
            l_ctx->mTextureUnits[unit] = l_ctx->mTextureUnits[unit];
        }
    } while (false);

    mEncoder->Uint16(106);  // Type ID -- TODO: mEncoder->Id(GL_ACTIVE_TEXTURE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(unit));
}

inline void GlesSpy::glGenTextures(int32_t count, uint32_t* textures) {
    GAPID_INFO("glGenTextures()\n");
    mImports.glGenTextures(count, textures);

    do {
        Slice<TextureId> l_t = slice(textures, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_61_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_61_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            TextureId l_id = (TextureId)(
                    read(slice(textures, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mTextures[l_id] = std::shared_ptr<Texture>((new Texture()));
            write(l_t, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(107);  // Type ID -- TODO: mEncoder->Id(GL_GEN_TEXTURES_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(textures));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glDeleteTextures(int32_t count, uint32_t* textures) {
    GAPID_INFO("glDeleteTextures()\n");
    mImports.glDeleteTextures(count, textures);

    do {
        Slice<TextureId> l_t = slice(textures, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_62_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_62_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mTextures[read(l_t, (uint64_t)(l_i))] = std::shared_ptr<Texture>();
        }
    } while (false);

    mEncoder->Uint16(108);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_TEXTURES_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(textures));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsTexture(uint32_t texture) {
    GAPID_INFO("glIsTexture()\n");
    bool result = mImports.glIsTexture(texture);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_63_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_63_result;
        break;
    } while (false);

    mEncoder->Uint16(109);  // Type ID -- TODO: mEncoder->Id(GL_IS_TEXTURE_ID);
    encodeObservations();
    mEncoder->Uint32(texture);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glBindTexture(uint32_t target, uint32_t texture) {
    GAPID_INFO("glBindTexture()\n");
    mImports.glBindTexture(target, texture);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_64_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_64_result;
        if (!(l_ctx->mInstances.mTextures.count(texture) > 0)) {
            l_ctx->mInstances.mTextures[texture] = std::shared_ptr<Texture>((new Texture()));
        }
        l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit][target] = texture;
    } while (false);

    mEncoder->Uint16(110);  // Type ID -- TODO: mEncoder->Id(GL_BIND_TEXTURE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(texture);
}

inline void GlesSpy::glTexImage2D(uint32_t target, int32_t level, uint32_t internal_format,
                                  int32_t width, int32_t height, int32_t border, uint32_t format,
                                  uint32_t type, void* data) {
    GAPID_INFO("glTexImage2D()\n");
    mImports.glTexImage2D(target, level, internal_format, width, height, border, format, type,
                          data);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_65_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_65_result;
        switch (target) {
            case TextureImageTarget::GL_TEXTURE_2D: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_2D];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize(imageSize((uint32_t)(width), (uint32_t)(height),
                                                       format, type))
                                    .SetFormat((uint32_t)(format));
                if (data != nullptr) {
                    if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] ==
                        (BufferId)(0)) {
                        l_l.mData = clone(
                                slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                    }
                } else {
                    l_l.mData = make<uint8_t>((uint64_t)(l_l.mSize));
                }
                l_t->mTexture2D[level] = l_l;
                l_t->mKind = TextureKind::TEXTURE2D;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_CUBE_MAP];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize(imageSize((uint32_t)(width), (uint32_t)(height),
                                                       format, type))
                                    .SetFormat((uint32_t)(format));
                if (data != nullptr) {
                    if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] ==
                        (BufferId)(0)) {
                        l_l.mData = clone(
                                slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                    }
                } else {
                    l_l.mData = make<uint8_t>((uint64_t)(l_l.mSize));
                }
                CubemapLevel l_cube = l_t->mCubemap[level];
                l_cube.mFaces[(uint32_t)(target)] = l_l;
                l_t->mCubemap[level] = l_cube;
                l_t->mKind = TextureKind::CUBEMAP;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(111);  // Type ID -- TODO: mEncoder->Id(GL_TEX_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Uint32(static_cast<uint32_t>(internal_format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Int32(border);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Uint32(static_cast<uint32_t>(type));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset,
                                     int32_t yoffset, int32_t width, int32_t height,
                                     uint32_t format, uint32_t type, void* data) {
    GAPID_INFO("glTexSubImage2D()\n");
    mImports.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_66_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_66_result;
        switch (target) {
            case TextureImageTarget::GL_TEXTURE_2D: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_2D];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize(imageSize((uint32_t)(width), (uint32_t)(height),
                                                       format, type))
                                    .SetFormat((uint32_t)(format));
                if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] == (BufferId)(0) &&
                    data != nullptr) {
                    l_l.mData =
                            clone(slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                }
                l_t->mTexture2D[level] = l_l;
                l_t->mKind = TextureKind::TEXTURE2D;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_CUBE_MAP];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize(imageSize((uint32_t)(width), (uint32_t)(height),
                                                       format, type))
                                    .SetFormat((uint32_t)(format));
                if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] == (BufferId)(0) &&
                    data != nullptr) {
                    l_l.mData =
                            clone(slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                }
                CubemapLevel l_cube = l_t->mCubemap[level];
                l_cube.mFaces[(uint32_t)(target)] = l_l;
                l_t->mCubemap[level] = l_cube;
                l_t->mKind = TextureKind::CUBEMAP;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(112);  // Type ID -- TODO: mEncoder->Id(GL_TEX_SUB_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Int32(xoffset);
    mEncoder->Int32(yoffset);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Uint32(static_cast<uint32_t>(type));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glCopyTexImage2D(uint32_t target, int32_t level, uint32_t format, int32_t x,
                                      int32_t y, int32_t width, int32_t height, int32_t border) {
    GAPID_INFO("glCopyTexImage2D()\n");
    mImports.glCopyTexImage2D(target, level, format, x, y, width, height, border);

    do {
    } while (false);

    mEncoder->Uint16(113);  // Type ID -- TODO: mEncoder->Id(GL_COPY_TEX_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Int32(border);
}

inline void GlesSpy::glCopyTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset,
                                         int32_t yoffset, int32_t x, int32_t y, int32_t width,
                                         int32_t height) {
    GAPID_INFO("glCopyTexSubImage2D()\n");
    mImports.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

    do {
    } while (false);

    mEncoder->Uint16(114);  // Type ID -- TODO: mEncoder->Id(GL_COPY_TEX_SUB_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Int32(xoffset);
    mEncoder->Int32(yoffset);
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glCompressedTexImage2D(uint32_t target, int32_t level, uint32_t format,
                                            int32_t width, int32_t height, int32_t border,
                                            int32_t image_size, void* data) {
    GAPID_INFO("glCompressedTexImage2D()\n");
    mImports.glCompressedTexImage2D(target, level, format, width, height, border, image_size, data);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_67_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_67_result;
        switch (target) {
            case TextureImageTarget::GL_TEXTURE_2D: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_2D];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize((uint32_t)(image_size))
                                    .SetFormat((uint32_t)(format));
                if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] == (BufferId)(0) &&
                    data != nullptr) {
                    l_l.mData =
                            clone(slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                }
                l_t->mTexture2D[level] = l_l;
                l_t->mKind = TextureKind::TEXTURE2D;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:  // fall-through...
            case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: {
                TextureId l_id = l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                     [TextureTarget::GL_TEXTURE_CUBE_MAP];
                std::shared_ptr<Texture> l_t = l_ctx->mInstances.mTextures[l_id];
                Image l_l = Image()
                                    .SetWidth(width)
                                    .SetHeight(height)
                                    .SetSize((uint32_t)(image_size))
                                    .SetFormat((uint32_t)(format));
                if (l_ctx->mBoundBuffers[BufferTarget::GL_PIXEL_UNPACK_BUFFER] == (BufferId)(0) &&
                    data != nullptr) {
                    l_l.mData =
                            clone(slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(l_l.mSize)));
                }
                CubemapLevel l_cube = l_t->mCubemap[level];
                l_cube.mFaces[(uint32_t)(target)] = l_l;
                l_t->mCubemap[level] = l_cube;
                l_t->mKind = TextureKind::CUBEMAP;
                l_t->mFormat = (uint32_t)(format);
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(115);  // Type ID -- TODO: mEncoder->Id(GL_COMPRESSED_TEX_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Int32(border);
    mEncoder->Int32(image_size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glCompressedTexSubImage2D(uint32_t target, int32_t level, int32_t xoffset,
                                               int32_t yoffset, int32_t width, int32_t height,
                                               uint32_t format, int32_t image_size, void* data) {
    GAPID_INFO("glCompressedTexSubImage2D()\n");
    mImports.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format,
                                       image_size, data);

    do {
    } while (false);

    mEncoder->Uint16(116);  // Type ID -- TODO: mEncoder->Id(GL_COMPRESSED_TEX_SUB_IMAGE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(level);
    mEncoder->Int32(xoffset);
    mEncoder->Int32(yoffset);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(image_size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGenerateMipmap(uint32_t target) {
    GAPID_INFO("glGenerateMipmap()\n");
    mImports.glGenerateMipmap(target);

    do {
    } while (false);

    mEncoder->Uint16(117);  // Type ID -- TODO: mEncoder->Id(GL_GENERATE_MIPMAP_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
}

inline void GlesSpy::glReadPixels(int32_t x, int32_t y, int32_t width, int32_t height,
                                  uint32_t format, uint32_t type, void* data) {
    GAPID_INFO("glReadPixels()\n");
    mImports.glReadPixels(x, y, width, height, format, type, data);

    do {
        write(slice(data, (uint64_t)(0), (uint64_t)(imageSize((uint32_t)(width), (uint32_t)(height),
                                                              (uint32_t)(format), type))));
    } while (false);

    mEncoder->Uint16(118);  // Type ID -- TODO: mEncoder->Id(GL_READ_PIXELS_ID);
    encodeObservations();
    mEncoder->Int32(x);
    mEncoder->Int32(y);
    mEncoder->Int32(width);
    mEncoder->Int32(height);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Uint32(static_cast<uint32_t>(type));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGenFramebuffers(int32_t count, uint32_t* framebuffers) {
    GAPID_INFO("glGenFramebuffers()\n");
    mImports.glGenFramebuffers(count, framebuffers);

    do {
        Slice<FramebufferId> l_f = slice(framebuffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_68_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_68_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            FramebufferId l_id = (FramebufferId)(
                    read(slice(framebuffers, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mFramebuffers[l_id] =
                    std::shared_ptr<Framebuffer>((new Framebuffer()));
            write(l_f, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(119);  // Type ID -- TODO: mEncoder->Id(GL_GEN_FRAMEBUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(framebuffers));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBindFramebuffer(uint32_t target, uint32_t framebuffer) {
    GAPID_INFO("glBindFramebuffer()\n");
    mImports.glBindFramebuffer(target, framebuffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_69_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_69_result;
        if (!(l_ctx->mInstances.mFramebuffers.count(framebuffer) > 0)) {
            l_ctx->mInstances.mFramebuffers[framebuffer] =
                    std::shared_ptr<Framebuffer>((new Framebuffer()));
        }
        if (target == FramebufferTarget::GL_FRAMEBUFFER) {
            l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER] = framebuffer;
            l_ctx->mBoundFramebuffers[FramebufferTarget::GL_DRAW_FRAMEBUFFER] = framebuffer;
        } else {
            l_ctx->mBoundFramebuffers[target] = framebuffer;
        }
    } while (false);

    mEncoder->Uint16(120);  // Type ID -- TODO: mEncoder->Id(GL_BIND_FRAMEBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(framebuffer);
}

inline uint32_t GlesSpy::glCheckFramebufferStatus(uint32_t target) {
    GAPID_INFO("glCheckFramebufferStatus()\n");
    uint32_t result = mImports.glCheckFramebufferStatus(target);

    do {
        break;
    } while (false);

    mEncoder->Uint16(121);  // Type ID -- TODO: mEncoder->Id(GL_CHECK_FRAMEBUFFER_STATUS_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(result));

    return result;
}

inline void GlesSpy::glDeleteFramebuffers(int32_t count, uint32_t* framebuffers) {
    GAPID_INFO("glDeleteFramebuffers()\n");
    mImports.glDeleteFramebuffers(count, framebuffers);

    do {
        Slice<FramebufferId> l_f = slice(framebuffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_70_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_70_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mFramebuffers[read(l_f, (uint64_t)(l_i))] =
                    std::shared_ptr<Framebuffer>();
        }
    } while (false);

    mEncoder->Uint16(122);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_FRAMEBUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(framebuffers));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsFramebuffer(uint32_t framebuffer) {
    GAPID_INFO("glIsFramebuffer()\n");
    bool result = mImports.glIsFramebuffer(framebuffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_71_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_71_result;
        break;
    } while (false);

    mEncoder->Uint16(123);  // Type ID -- TODO: mEncoder->Id(GL_IS_FRAMEBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(framebuffer);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glGenRenderbuffers(int32_t count, uint32_t* renderbuffers) {
    GAPID_INFO("glGenRenderbuffers()\n");
    mImports.glGenRenderbuffers(count, renderbuffers);

    do {
        Slice<RenderbufferId> l_r = slice(renderbuffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_72_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_72_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            RenderbufferId l_id = (RenderbufferId)(
                    read(slice(renderbuffers, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mRenderbuffers[l_id] =
                    std::shared_ptr<Renderbuffer>((new Renderbuffer()));
            write(l_r, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(124);  // Type ID -- TODO: mEncoder->Id(GL_GEN_RENDERBUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(renderbuffers));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBindRenderbuffer(uint32_t target, uint32_t renderbuffer) {
    GAPID_INFO("glBindRenderbuffer()\n");
    mImports.glBindRenderbuffer(target, renderbuffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_73_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_73_result;
        if (!(l_ctx->mInstances.mRenderbuffers.count(renderbuffer) > 0)) {
            l_ctx->mInstances.mRenderbuffers[renderbuffer] =
                    std::shared_ptr<Renderbuffer>((new Renderbuffer()));
        }
        l_ctx->mBoundRenderbuffers[target] = renderbuffer;
    } while (false);

    mEncoder->Uint16(125);  // Type ID -- TODO: mEncoder->Id(GL_BIND_RENDERBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(renderbuffer);
}

inline void GlesSpy::glRenderbufferStorage(uint32_t target, uint32_t format, int32_t width,
                                           int32_t height) {
    GAPID_INFO("glRenderbufferStorage()\n");
    mImports.glRenderbufferStorage(target, format, width, height);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_74_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_74_result;
        RenderbufferId l_id = l_ctx->mBoundRenderbuffers[target];
        std::shared_ptr<Renderbuffer> l_rb = l_ctx->mInstances.mRenderbuffers[l_id];
        l_rb->mFormat = format;
        l_rb->mWidth = width;
        l_rb->mHeight = height;
    } while (false);

    mEncoder->Uint16(126);  // Type ID -- TODO: mEncoder->Id(GL_RENDERBUFFER_STORAGE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffers) {
    GAPID_INFO("glDeleteRenderbuffers()\n");
    mImports.glDeleteRenderbuffers(count, renderbuffers);

    do {
        Slice<RenderbufferId> l_r = slice(renderbuffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_75_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_75_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mRenderbuffers[read(l_r, (uint64_t)(l_i))] =
                    std::shared_ptr<Renderbuffer>();
        }
    } while (false);

    mEncoder->Uint16(127);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_RENDERBUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(renderbuffers));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsRenderbuffer(uint32_t renderbuffer) {
    GAPID_INFO("glIsRenderbuffer()\n");
    bool result = mImports.glIsRenderbuffer(renderbuffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_76_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_76_result;
        break;
    } while (false);

    mEncoder->Uint16(128);  // Type ID -- TODO: mEncoder->Id(GL_IS_RENDERBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(renderbuffer);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glGetRenderbufferParameteriv(uint32_t target, uint32_t parameter,
                                                  int32_t* values) {
    GAPID_INFO("glGetRenderbufferParameteriv()\n");
    mImports.glGetRenderbufferParameteriv(target, parameter, values);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_77_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_77_result;
        RenderbufferId l_id = l_ctx->mBoundRenderbuffers[target];
        std::shared_ptr<Renderbuffer> l_rb = l_ctx->mInstances.mRenderbuffers[l_id];
        write(slice(values, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case RenderbufferParameter::GL_RENDERBUFFER_WIDTH: */(((parameter) == (RenderbufferParameter::GL_RENDERBUFFER_WIDTH))) ? (l_rb->mWidth) :
            /* case RenderbufferParameter::GL_RENDERBUFFER_HEIGHT: */(((parameter) == (RenderbufferParameter::GL_RENDERBUFFER_HEIGHT))) ? (l_rb->mHeight) :
            /* case RenderbufferParameter::GL_RENDERBUFFER_INTERNAL_FORMAT: */(((parameter) == (RenderbufferParameter::GL_RENDERBUFFER_INTERNAL_FORMAT))) ? ((int32_t)(l_rb->mFormat)) :
            /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(129);  // Type ID -- TODO: mEncoder->Id(GL_GET_RENDERBUFFER_PARAMETERIV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGenBuffers(int32_t count, uint32_t* buffers) {
    GAPID_INFO("glGenBuffers()\n");
    mImports.glGenBuffers(count, buffers);

    do {
        Slice<BufferId> l_b = slice(buffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_78_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_78_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            BufferId l_id = (BufferId)(
                    read(slice(buffers, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mBuffers[l_id] = std::shared_ptr<Buffer>((new Buffer()));
            write(l_b, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(130);  // Type ID -- TODO: mEncoder->Id(GL_GEN_BUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(buffers));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBindBuffer(uint32_t target, uint32_t buffer) {
    GAPID_INFO("glBindBuffer()\n");
    mImports.glBindBuffer(target, buffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_79_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_79_result;
        if (!(l_ctx->mInstances.mBuffers.count(buffer) > 0)) {
            l_ctx->mInstances.mBuffers[buffer] = std::shared_ptr<Buffer>((new Buffer()));
        }
        l_ctx->mBoundBuffers[target] = buffer;
    } while (false);

    mEncoder->Uint16(131);  // Type ID -- TODO: mEncoder->Id(GL_BIND_BUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(buffer);
}

inline void GlesSpy::glBufferData(uint32_t target, int32_t size, void* data, uint32_t usage) {
    GAPID_INFO("glBufferData()\n");
    mImports.glBufferData(target, size, data, usage);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_80_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_80_result;
        BufferId l_id = l_ctx->mBoundBuffers[target];
        std::shared_ptr<Buffer> l_b = l_ctx->mInstances.mBuffers[l_id];
        l_b->mData = /* clang-format off */
        /* switch(data != nullptr) */
            /* case true: */(((data != nullptr) == (true))) ? (clone(slice((uint8_t*)(data), (uint64_t)(0), (uint64_t)(size)))) :
            /* case false: */(((data != nullptr) == (false))) ? (make<uint8_t>((uint64_t)(size))) :
            /* default: */ Slice<uint8_t>() /* clang-format on */;
        l_b->mSize = size;
        l_b->mUsage = usage;
    } while (false);

    mEncoder->Uint16(132);  // Type ID -- TODO: mEncoder->Id(GL_BUFFER_DATA_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint32(static_cast<uint32_t>(usage));
}

inline void GlesSpy::glBufferSubData(uint32_t target, int32_t offset, int32_t size, void* data) {
    GAPID_INFO("glBufferSubData()\n");
    mImports.glBufferSubData(target, offset, size, data);

    do {
        read(slice(data, (uint64_t)(0), (uint64_t)(size)));
    } while (false);

    mEncoder->Uint16(133);  // Type ID -- TODO: mEncoder->Id(GL_BUFFER_SUB_DATA_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(offset);
    mEncoder->Int32(size);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(data));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glDeleteBuffers(int32_t count, uint32_t* buffers) {
    GAPID_INFO("glDeleteBuffers()\n");
    mImports.glDeleteBuffers(count, buffers);

    do {
        Slice<BufferId> l_b = slice(buffers, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_81_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_81_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mBuffers[read(l_b, (uint64_t)(l_i))] = std::shared_ptr<Buffer>();
        }
    } while (false);

    mEncoder->Uint16(134);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_BUFFERS_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(buffers));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsBuffer(uint32_t buffer) {
    GAPID_INFO("glIsBuffer()\n");
    bool result = mImports.glIsBuffer(buffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_82_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_82_result;
        break;
    } while (false);

    mEncoder->Uint16(135);  // Type ID -- TODO: mEncoder->Id(GL_IS_BUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(buffer);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glGetBufferParameteriv(uint32_t target, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetBufferParameteriv()\n");
    mImports.glGetBufferParameteriv(target, parameter, value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_83_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_83_result;
        BufferId l_id = l_ctx->mBoundBuffers[target];
        std::shared_ptr<Buffer> l_b = l_ctx->mInstances.mBuffers[l_id];
        write(slice(value, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case BufferParameter::GL_BUFFER_SIZE: */(((parameter) == (BufferParameter::GL_BUFFER_SIZE))) ? (l_b->mSize) :
            /* case BufferParameter::GL_BUFFER_USAGE: */(((parameter) == (BufferParameter::GL_BUFFER_USAGE))) ? ((int32_t)(l_b->mUsage)) :
            /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(136);  // Type ID -- TODO: mEncoder->Id(GL_GET_BUFFER_PARAMETERIV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline uint32_t GlesSpy::glCreateShader(uint32_t type) {
    GAPID_INFO("glCreateShader()\n");
    uint32_t result = mImports.glCreateShader(type);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_84_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_84_result;
        ShaderId l_id = (ShaderId)(result);
        l_ctx->mInstances.mShaders[l_id] = std::shared_ptr<Shader>((new Shader()));
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[l_id];
        l_s->mType = type;
        break;
    } while (false);

    mEncoder->Uint16(137);  // Type ID -- TODO: mEncoder->Id(GL_CREATE_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(type));
    mEncoder->Uint32(result);

    return result;
}

inline void GlesSpy::glDeleteShader(uint32_t shader) {
    GAPID_INFO("glDeleteShader()\n");
    mImports.glDeleteShader(shader);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_85_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_85_result;
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        l_s->mDeletable = true;
        l_ctx->mInstances.mShaders[shader] = std::shared_ptr<Shader>();
    } while (false);

    mEncoder->Uint16(138);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
}

inline void GlesSpy::glShaderSource(uint32_t shader, int32_t count, char** source,
                                    int32_t* length) {
    GAPID_INFO("glShaderSource()\n");
    mImports.glShaderSource(shader, count, source, length);

    do {
        Slice<char*> l_sources = slice(source, (uint64_t)(0), (uint64_t)(count));
        Slice<int32_t> l_lengths = slice(length, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_86_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_86_result;
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            uint32_t l_l = /* clang-format off */
            /* switch(length == nullptr || read(l_lengths, (uint64_t)(l_i)) < 0) */
                /* case true: */(((length == nullptr || read(l_lengths, (uint64_t)(l_i)) < 0) == (true))) ? (strlen(read(l_sources, (uint64_t)(l_i)))) :
                /* case false: */(((length == nullptr || read(l_lengths, (uint64_t)(l_i)) < 0) == (false))) ? ((uint32_t)(read(l_lengths, (uint64_t)(l_i)))) :
                /* default: */ 0 /* clang-format on */;
            l_s->mSource +=
                    string(slice(read(l_sources, (uint64_t)(l_i)), (uint64_t)(0), (uint64_t)(l_l)));
        }
    } while (false);

    mEncoder->Uint16(139);  // Type ID -- TODO: mEncoder->Id(GL_SHADER_SOURCE_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(source));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(length));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glShaderBinary(int32_t count, uint32_t* shaders, uint32_t binary_format,
                                    void* binary, int32_t binary_size) {
    GAPID_INFO("glShaderBinary()\n");
    mImports.glShaderBinary(count, shaders, binary_format, binary, binary_size);

    do {
        for (int32_t l_i = 0; l_i < count; ++l_i) {
        }
    } while (false);

    mEncoder->Uint16(140);  // Type ID -- TODO: mEncoder->Id(GL_SHADER_BINARY_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(shaders));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint32(binary_format);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(binary));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Int32(binary_size);
}

inline void GlesSpy::glGetShaderInfoLog(uint32_t shader, int32_t buffer_length,
                                        int32_t* string_length_written, char* info) {
    GAPID_INFO("glGetShaderInfoLog()\n");
    mImports.glGetShaderInfoLog(shader, buffer_length, string_length_written, info);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_87_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_87_result;
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        int32_t l_min_88_a = buffer_length;
        int32_t l_min_88_b = (int32_t)(strlen(l_s->mInfoLog));
        int32_t l_min_88_result = /* clang-format off */
        /* switch(l_min_88_a < l_min_88_b) */
            /* case true: */(((l_min_88_a < l_min_88_b) == (true))) ? (l_min_88_a) :
            /* case false: */(((l_min_88_a < l_min_88_b) == (false))) ? (l_min_88_b) :
            /* default: */ 0 /* clang-format on */;
        int32_t l_l = l_min_88_result;
        write(slice(string_length_written, 0, 1), 0, l_l);
        copy(slice(info, (uint64_t)(0), (uint64_t)(l_l)),
             slice(l_s->mInfoLog, (uint64_t)(0), (uint64_t)(l_l)));
    } while (false);

    mEncoder->Uint16(141);  // Type ID -- TODO: mEncoder->Id(GL_GET_SHADER_INFO_LOG_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
    mEncoder->Int32(buffer_length);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(string_length_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(info));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetShaderSource(uint32_t shader, int32_t buffer_length,
                                       int32_t* string_length_written, char* source) {
    GAPID_INFO("glGetShaderSource()\n");
    mImports.glGetShaderSource(shader, buffer_length, string_length_written, source);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_89_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_89_result;
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        int32_t l_min_90_a = buffer_length;
        int32_t l_min_90_b = (int32_t)(strlen(l_s->mSource));
        int32_t l_min_90_result = /* clang-format off */
        /* switch(l_min_90_a < l_min_90_b) */
            /* case true: */(((l_min_90_a < l_min_90_b) == (true))) ? (l_min_90_a) :
            /* case false: */(((l_min_90_a < l_min_90_b) == (false))) ? (l_min_90_b) :
            /* default: */ 0 /* clang-format on */;
        int32_t l_l = l_min_90_result;
        write(slice(string_length_written, 0, 1), 0, l_l);
        copy(slice(source, (uint64_t)(0), (uint64_t)(l_l)),
             slice(slice(l_s->mSource), (uint64_t)(0), (uint64_t)(l_l)));
    } while (false);

    mEncoder->Uint16(142);  // Type ID -- TODO: mEncoder->Id(GL_GET_SHADER_SOURCE_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
    mEncoder->Int32(buffer_length);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(string_length_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(source));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glReleaseShaderCompiler() {
    GAPID_INFO("glReleaseShaderCompiler()\n");
    mImports.glReleaseShaderCompiler();

    do {
    } while (false);

    mEncoder->Uint16(143);  // Type ID -- TODO: mEncoder->Id(GL_RELEASE_SHADER_COMPILER_ID);
    encodeObservations();
}

inline void GlesSpy::glCompileShader(uint32_t shader) {
    GAPID_INFO("glCompileShader()\n");
    mImports.glCompileShader(shader);

    do {
    } while (false);

    mEncoder->Uint16(144);  // Type ID -- TODO: mEncoder->Id(GL_COMPILE_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
}

inline bool GlesSpy::glIsShader(uint32_t shader) {
    GAPID_INFO("glIsShader()\n");
    bool result = mImports.glIsShader(shader);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_91_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_91_result;
        break;
    } while (false);

    mEncoder->Uint16(145);  // Type ID -- TODO: mEncoder->Id(GL_IS_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(shader);
    mEncoder->Bool(result);

    return result;
}

inline uint32_t GlesSpy::glCreateProgram() {
    GAPID_INFO("glCreateProgram()\n");
    uint32_t result = mImports.glCreateProgram();

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_92_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_92_result;
        ProgramId l_id = (ProgramId)(result);
        l_ctx->mInstances.mPrograms[l_id] = std::shared_ptr<Program>((new Program()));
        break;
    } while (false);

    mEncoder->Uint16(146);  // Type ID -- TODO: mEncoder->Id(GL_CREATE_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(result);

    return result;
}

inline void GlesSpy::glDeleteProgram(uint32_t program) {
    GAPID_INFO("glDeleteProgram()\n");
    mImports.glDeleteProgram(program);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_93_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_93_result;
        l_ctx->mInstances.mPrograms[program] = std::shared_ptr<Program>();
    } while (false);

    mEncoder->Uint16(147);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
}

inline void GlesSpy::glAttachShader(uint32_t program, uint32_t shader) {
    GAPID_INFO("glAttachShader()\n");
    mImports.glAttachShader(program, shader);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_94_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_94_result;
        std::shared_ptr<Program> l_p = l_ctx->mInstances.mPrograms[program];
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        l_p->mShaders[l_s->mType] = shader;
    } while (false);

    mEncoder->Uint16(148);  // Type ID -- TODO: mEncoder->Id(GL_ATTACH_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(shader);
}

inline void GlesSpy::glDetachShader(uint32_t program, uint32_t shader) {
    GAPID_INFO("glDetachShader()\n");
    mImports.glDetachShader(program, shader);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_95_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_95_result;
        std::shared_ptr<Program> l_p = l_ctx->mInstances.mPrograms[program];
        std::shared_ptr<Shader> l_s = l_ctx->mInstances.mShaders[shader];
        l_p->mShaders[l_s->mType] = 0;
    } while (false);

    mEncoder->Uint16(149);  // Type ID -- TODO: mEncoder->Id(GL_DETACH_SHADER_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Uint32(shader);
}

inline void GlesSpy::glGetAttachedShaders(uint32_t program, int32_t buffer_length,
                                          int32_t* shaders_length_written, uint32_t* shaders) {
    GAPID_INFO("glGetAttachedShaders()\n");
    mImports.glGetAttachedShaders(program, buffer_length, shaders_length_written, shaders);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_96_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_96_result;
        std::shared_ptr<Program> l_p = l_ctx->mInstances.mPrograms[program];
        int32_t l_min_97_a = buffer_length;
        int32_t l_min_97_b = l_p->mShaders.size();
        int32_t l_min_97_result = /* clang-format off */
        /* switch(l_min_97_a < l_min_97_b) */
            /* case true: */(((l_min_97_a < l_min_97_b) == (true))) ? (l_min_97_a) :
            /* case false: */(((l_min_97_a < l_min_97_b) == (false))) ? (l_min_97_b) :
            /* default: */ 0 /* clang-format on */;
        int32_t l_l = l_min_97_result;
        write(slice(shaders_length_written, 0, 1), 0, l_l);
    } while (false);

    mEncoder->Uint16(150);  // Type ID -- TODO: mEncoder->Id(GL_GET_ATTACHED_SHADERS_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(buffer_length);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(shaders_length_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(shaders));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glLinkProgram(uint32_t program) {
    GAPID_INFO("glLinkProgram()\n");
    mImports.glLinkProgram(program);

    do {
    } while (false);

    mEncoder->Uint16(151);  // Type ID -- TODO: mEncoder->Id(GL_LINK_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
}

inline void GlesSpy::glGetProgramInfoLog(uint32_t program, int32_t buffer_length,
                                         int32_t* string_length_written, char* info) {
    GAPID_INFO("glGetProgramInfoLog()\n");
    mImports.glGetProgramInfoLog(program, buffer_length, string_length_written, info);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_98_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_98_result;
        std::shared_ptr<Program> l_p = l_ctx->mInstances.mPrograms[program];
        int32_t l_min_99_a = buffer_length;
        int32_t l_min_99_b = (int32_t)(strlen(l_p->mInfoLog));
        int32_t l_min_99_result = /* clang-format off */
        /* switch(l_min_99_a < l_min_99_b) */
            /* case true: */(((l_min_99_a < l_min_99_b) == (true))) ? (l_min_99_a) :
            /* case false: */(((l_min_99_a < l_min_99_b) == (false))) ? (l_min_99_b) :
            /* default: */ 0 /* clang-format on */;
        int32_t l_l = l_min_99_result;
        write(slice(string_length_written, 0, 1), 0, l_l);
        copy(slice(info, (uint64_t)(0), (uint64_t)(l_l)),
             slice(l_p->mInfoLog, (uint64_t)(0), (uint64_t)(l_l)));
    } while (false);

    mEncoder->Uint16(152);  // Type ID -- TODO: mEncoder->Id(GL_GET_PROGRAM_INFO_LOG_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Int32(buffer_length);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(string_length_written));
    mEncoder->Uint32(0);  // PoolID
    mEncoder->Uint64(reinterpret_cast<uint64_t>(info));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glUseProgram(uint32_t program) {
    GAPID_INFO("glUseProgram()\n");
    mImports.glUseProgram(program);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_100_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_100_result;
        l_ctx->mBoundProgram = program;
    } while (false);

    mEncoder->Uint16(153);  // Type ID -- TODO: mEncoder->Id(GL_USE_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
}

inline bool GlesSpy::glIsProgram(uint32_t program) {
    GAPID_INFO("glIsProgram()\n");
    bool result = mImports.glIsProgram(program);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_101_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_101_result;
        break;
    } while (false);

    mEncoder->Uint16(154);  // Type ID -- TODO: mEncoder->Id(GL_IS_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glValidateProgram(uint32_t program) {
    GAPID_INFO("glValidateProgram()\n");
    mImports.glValidateProgram(program);

    do {
    } while (false);

    mEncoder->Uint16(155);  // Type ID -- TODO: mEncoder->Id(GL_VALIDATE_PROGRAM_ID);
    encodeObservations();
    mEncoder->Uint32(program);
}

inline void GlesSpy::glClearColor(float r, float g, float b, float a) {
    GAPID_INFO("glClearColor()\n");
    mImports.glClearColor(r, g, b, a);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_102_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_102_result;
        l_ctx->mClearing.mClearColor = Color().SetRed(r).SetGreen(g).SetBlue(b).SetAlpha(a);
    } while (false);

    mEncoder->Uint16(156);  // Type ID -- TODO: mEncoder->Id(GL_CLEAR_COLOR_ID);
    encodeObservations();
    mEncoder->Float32(r);
    mEncoder->Float32(g);
    mEncoder->Float32(b);
    mEncoder->Float32(a);
}

inline void GlesSpy::glClearDepthf(float depth) {
    GAPID_INFO("glClearDepthf()\n");
    mImports.glClearDepthf(depth);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_103_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_103_result;
        l_ctx->mClearing.mClearDepth = depth;
    } while (false);

    mEncoder->Uint16(157);  // Type ID -- TODO: mEncoder->Id(GL_CLEAR_DEPTHF_ID);
    encodeObservations();
    mEncoder->Float32(depth);
}

inline void GlesSpy::glClearStencil(int32_t stencil) {
    GAPID_INFO("glClearStencil()\n");
    mImports.glClearStencil(stencil);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_104_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_104_result;
        l_ctx->mClearing.mClearStencil = stencil;
    } while (false);

    mEncoder->Uint16(158);  // Type ID -- TODO: mEncoder->Id(GL_CLEAR_STENCIL_ID);
    encodeObservations();
    mEncoder->Int32(stencil);
}

inline void GlesSpy::glClear(uint32_t mask) {
    GAPID_INFO("glClear()\n");
    mImports.glClear(mask);

    do {
        if ((mask & ClearMask::GL_COLOR_BUFFER_BIT) != 0) {
        }
    } while (false);

    mEncoder->Uint16(159);  // Type ID -- TODO: mEncoder->Id(GL_CLEAR_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(mask));
}

inline void GlesSpy::glCullFace(uint32_t mode) {
    GAPID_INFO("glCullFace()\n");
    mImports.glCullFace(mode);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_105_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_105_result;
        l_ctx->mRasterizing.mCullFace = mode;
    } while (false);

    mEncoder->Uint16(160);  // Type ID -- TODO: mEncoder->Id(GL_CULL_FACE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(mode));
}

inline void GlesSpy::glPolygonOffset(float scale_factor, float units) {
    GAPID_INFO("glPolygonOffset()\n");
    mImports.glPolygonOffset(scale_factor, units);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_106_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_106_result;
        l_ctx->mRasterizing.mPolygonOffsetUnits = units;
        l_ctx->mRasterizing.mPolygonOffsetFactor = scale_factor;
    } while (false);

    mEncoder->Uint16(161);  // Type ID -- TODO: mEncoder->Id(GL_POLYGON_OFFSET_ID);
    encodeObservations();
    mEncoder->Float32(scale_factor);
    mEncoder->Float32(units);
}

inline void GlesSpy::glLineWidth(float width) {
    GAPID_INFO("glLineWidth()\n");
    mImports.glLineWidth(width);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_107_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_107_result;
        l_ctx->mRasterizing.mLineWidth = width;
    } while (false);

    mEncoder->Uint16(162);  // Type ID -- TODO: mEncoder->Id(GL_LINE_WIDTH_ID);
    encodeObservations();
    mEncoder->Float32(width);
}

inline void GlesSpy::glSampleCoverage(float value, bool invert) {
    GAPID_INFO("glSampleCoverage()\n");
    mImports.glSampleCoverage(value, invert);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_108_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_108_result;
        l_ctx->mRasterizing.mSampleCoverageValue = value;
        l_ctx->mRasterizing.mSampleCoverageInvert = invert;
    } while (false);

    mEncoder->Uint16(163);  // Type ID -- TODO: mEncoder->Id(GL_SAMPLE_COVERAGE_ID);
    encodeObservations();
    mEncoder->Float32(value);
    mEncoder->Bool(invert);
}

inline void GlesSpy::glHint(uint32_t target, uint32_t mode) {
    GAPID_INFO("glHint()\n");
    mImports.glHint(target, mode);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_109_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_109_result;
        l_ctx->mGenerateMipmapHint = mode;
    } while (false);

    mEncoder->Uint16(164);  // Type ID -- TODO: mEncoder->Id(GL_HINT_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(mode));
}

inline void GlesSpy::glFramebufferRenderbuffer(uint32_t framebuffer_target,
                                               uint32_t framebuffer_attachment,
                                               uint32_t renderbuffer_target,
                                               uint32_t renderbuffer) {
    GAPID_INFO("glFramebufferRenderbuffer()\n");
    mImports.glFramebufferRenderbuffer(framebuffer_target, framebuffer_attachment,
                                       renderbuffer_target, renderbuffer);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_110_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_110_result;
        uint32_t l_target = /* clang-format off */
        /* switch(framebuffer_target) */
            /* case FramebufferTarget::GL_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_DRAW_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_DRAW_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_READ_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_READ_FRAMEBUFFER))) ? (FramebufferTarget::GL_READ_FRAMEBUFFER) :
            /* default: */ 0 /* clang-format on */;
        FramebufferId l_framebufferId = l_ctx->mBoundFramebuffers[l_target];
        std::shared_ptr<Framebuffer> l_framebuffer =
                l_ctx->mInstances.mFramebuffers[l_framebufferId];
        FramebufferAttachmentInfo l_attachment =
                l_framebuffer->mAttachments[framebuffer_attachment];
        if (renderbuffer == (RenderbufferId)(0)) {
            l_attachment.mType = FramebufferAttachmentType::GL_NONE;
        } else {
            l_attachment.mType = FramebufferAttachmentType::GL_RENDERBUFFER;
        }
        l_attachment.mObject = (uint32_t)(renderbuffer);
        l_attachment.mTextureLevel = 0;
        l_attachment.mCubeMapFace = CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X;
        l_framebuffer->mAttachments[framebuffer_attachment] = l_attachment;
    } while (false);

    mEncoder->Uint16(165);  // Type ID -- TODO: mEncoder->Id(GL_FRAMEBUFFER_RENDERBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(framebuffer_target));
    mEncoder->Uint32(static_cast<uint32_t>(framebuffer_attachment));
    mEncoder->Uint32(static_cast<uint32_t>(renderbuffer_target));
    mEncoder->Uint32(renderbuffer);
}

inline void GlesSpy::glFramebufferTexture2D(uint32_t framebuffer_target,
                                            uint32_t framebuffer_attachment,
                                            uint32_t texture_target, uint32_t texture,
                                            int32_t level) {
    GAPID_INFO("glFramebufferTexture2D()\n");
    mImports.glFramebufferTexture2D(framebuffer_target, framebuffer_attachment, texture_target,
                                    texture, level);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_111_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_111_result;
        uint32_t l_target = /* clang-format off */
        /* switch(framebuffer_target) */
            /* case FramebufferTarget::GL_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_DRAW_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_DRAW_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_READ_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_READ_FRAMEBUFFER))) ? (FramebufferTarget::GL_READ_FRAMEBUFFER) :
            /* default: */ 0 /* clang-format on */;
        FramebufferId l_framebufferId = l_ctx->mBoundFramebuffers[l_target];
        std::shared_ptr<Framebuffer> l_framebuffer =
                l_ctx->mInstances.mFramebuffers[l_framebufferId];
        FramebufferAttachmentInfo l_attachment =
                l_framebuffer->mAttachments[framebuffer_attachment];
        if (texture == (TextureId)(0)) {
            l_attachment.mType = FramebufferAttachmentType::GL_NONE;
            l_attachment.mObject = 0;
            l_attachment.mTextureLevel = 0;
            l_attachment.mCubeMapFace = CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X;
        } else {
            l_attachment.mType = FramebufferAttachmentType::GL_TEXTURE;
            l_attachment.mObject = (uint32_t)(texture);
            l_attachment.mTextureLevel = level;
            l_attachment.mCubeMapFace = /* clang-format off */
            /* switch(texture_target) */
                /* case TextureImageTarget::GL_TEXTURE_2D: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_2D))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_X) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Y) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_POSITIVE_Z) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_X) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Y) :
                /* case TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: */(((texture_target) == (TextureImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z))) ? (CubeMapImageTarget::GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) :
                /* default: */ 0 /* clang-format on */;
        }
        l_framebuffer->mAttachments[framebuffer_attachment] = l_attachment;
    } while (false);

    mEncoder->Uint16(166);  // Type ID -- TODO: mEncoder->Id(GL_FRAMEBUFFER_TEXTURE2D_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(framebuffer_target));
    mEncoder->Uint32(static_cast<uint32_t>(framebuffer_attachment));
    mEncoder->Uint32(static_cast<uint32_t>(texture_target));
    mEncoder->Uint32(texture);
    mEncoder->Int32(level);
}

inline void GlesSpy::glGetFramebufferAttachmentParameteriv(uint32_t framebuffer_target,
                                                           uint32_t attachment, uint32_t parameter,
                                                           int32_t* value) {
    GAPID_INFO("glGetFramebufferAttachmentParameteriv()\n");
    mImports.glGetFramebufferAttachmentParameteriv(framebuffer_target, attachment, parameter,
                                                   value);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_112_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_112_result;
        uint32_t l_target = /* clang-format off */
        /* switch(framebuffer_target) */
            /* case FramebufferTarget::GL_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_DRAW_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_DRAW_FRAMEBUFFER))) ? (FramebufferTarget::GL_DRAW_FRAMEBUFFER) :
            /* case FramebufferTarget::GL_READ_FRAMEBUFFER: */(((framebuffer_target) == (FramebufferTarget::GL_READ_FRAMEBUFFER))) ? (FramebufferTarget::GL_READ_FRAMEBUFFER) :
            /* default: */ 0 /* clang-format on */;
        FramebufferId l_framebufferId = l_ctx->mBoundFramebuffers[l_target];
        std::shared_ptr<Framebuffer> l_framebuffer =
                l_ctx->mInstances.mFramebuffers[l_framebufferId];
        FramebufferAttachmentInfo l_a = l_framebuffer->mAttachments[attachment];
        write(slice(value, 0, 1), 0, /* clang-format off */
        /* switch(parameter) */
            /* case FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: */(((parameter) == (FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE))) ? ((int32_t)(l_a.mType)) :
            /* case FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: */(((parameter) == (FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME))) ? ((int32_t)(l_a.mObject)) :
            /* case FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: */(((parameter) == (FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL))) ? (l_a.mTextureLevel) :
            /* case FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: */(((parameter) == (FramebufferAttachmentParameter::GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE))) ? ((int32_t)(l_a.mCubeMapFace)) :
            /* default: */ 0 /* clang-format on */);
    } while (false);

    mEncoder->Uint16(
            167);  // Type ID -- TODO: mEncoder->Id(GL_GET_FRAMEBUFFER_ATTACHMENT_PARAMETERIV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(framebuffer_target));
    mEncoder->Uint32(static_cast<uint32_t>(attachment));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glDrawElements(uint32_t draw_mode, int32_t element_count,
                                    uint32_t indices_type, void* indices) {
    GAPID_INFO("glDrawElements()\n");
    mImports.glDrawElements(draw_mode, element_count, indices_type, indices);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_113_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_113_result;
        uint32_t l_count = (uint32_t)(element_count);
        BufferId l_id = l_ctx->mBoundBuffers[BufferTarget::GL_ELEMENT_ARRAY_BUFFER];
        if (l_id != (BufferId)(0)) {
            Slice<uint8_t> l_index_data = l_ctx->mInstances.mBuffers[l_id]->mData;
            uint32_t l_offset = (uint32_t)((uint64_t)(indices));
            uint32_t l_first = minIndex(l_index_data.begin(), indices_type, l_offset, l_count);
            uint32_t l_last = maxIndex(l_index_data.begin(), indices_type, l_offset, l_count);
            std::shared_ptr<Context> l_ReadVertexArrays_114_ctx = l_ctx;
            uint32_t l_ReadVertexArrays_114_first_index = l_first;
            uint32_t l_ReadVertexArrays_114_last_index = l_last;
            for (int32_t l_i = 0; l_i < l_ReadVertexArrays_114_ctx->mVertexAttributeArrays.size();
                 ++l_i) {
                std::shared_ptr<VertexAttributeArray> l_arr =
                        l_ReadVertexArrays_114_ctx
                                ->mVertexAttributeArrays[(AttributeLocation)(l_i)];
                if (l_arr->mEnabled && l_arr->mBuffer == (BufferId)(0)) {
                    uint32_t l_vertexAttribTypeSize_115_t = l_arr->mType;
                    uint32_t l_vertexAttribTypeSize_115_result = /* clang-format off */
                    /* switch(l_vertexAttribTypeSize_115_t) */
                        /* case VertexAttribType::GL_BYTE: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_BYTE))) ? (1) :
                        /* case VertexAttribType::GL_UNSIGNED_BYTE: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_UNSIGNED_BYTE))) ? (1) :
                        /* case VertexAttribType::GL_SHORT: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_SHORT))) ? (2) :
                        /* case VertexAttribType::GL_UNSIGNED_SHORT: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_UNSIGNED_SHORT))) ? (2) :
                        /* case VertexAttribType::GL_FIXED: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_FIXED))) ? (4) :
                        /* case VertexAttribType::GL_FLOAT: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_FLOAT))) ? (4) :
                        /* case VertexAttribType::GL_ARB_half_float_vertex: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_ARB_half_float_vertex))) ? (2) :
                        /* case VertexAttribType::GL_HALF_FLOAT_OES: */(((l_vertexAttribTypeSize_115_t) == (VertexAttribType::GL_HALF_FLOAT_OES))) ? (2) :
                        /* default: */ 0 /* clang-format on */;
                    uint32_t l_elsize = l_vertexAttribTypeSize_115_result * l_arr->mSize;
                    uint32_t l_elstride = /* clang-format off */
                    /* switch(l_arr->mStride == 0) */
                        /* case true: */(((l_arr->mStride == 0) == (true))) ? (l_elsize) :
                        /* case false: */(((l_arr->mStride == 0) == (false))) ? ((uint32_t)(l_arr->mStride)) :
                        /* default: */ 0 /* clang-format on */;
                    for (uint32_t l_v = l_ReadVertexArrays_114_first_index;
                         l_v < l_ReadVertexArrays_114_last_index + 1; ++l_v) {
                        uint32_t l_offset = l_elstride * l_v;
                        read(slice(l_arr->mPointer, (uint64_t)(l_offset),
                                   (uint64_t)(l_offset + l_elsize)));
                    }
                }
            }
        } else {
            uint8_t* l_index_data = (uint8_t*)(indices);
            uint32_t l_first = minIndex(l_index_data, indices_type, 0, l_count);
            uint32_t l_last = maxIndex(l_index_data, indices_type, 0, l_count);
            std::shared_ptr<Context> l_ReadVertexArrays_116_ctx = l_ctx;
            uint32_t l_ReadVertexArrays_116_first_index = l_first;
            uint32_t l_ReadVertexArrays_116_last_index = l_last;
            for (int32_t l_i = 0; l_i < l_ReadVertexArrays_116_ctx->mVertexAttributeArrays.size();
                 ++l_i) {
                std::shared_ptr<VertexAttributeArray> l_arr =
                        l_ReadVertexArrays_116_ctx
                                ->mVertexAttributeArrays[(AttributeLocation)(l_i)];
                if (l_arr->mEnabled && l_arr->mBuffer == (BufferId)(0)) {
                    uint32_t l_vertexAttribTypeSize_117_t = l_arr->mType;
                    uint32_t l_vertexAttribTypeSize_117_result = /* clang-format off */
                    /* switch(l_vertexAttribTypeSize_117_t) */
                        /* case VertexAttribType::GL_BYTE: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_BYTE))) ? (1) :
                        /* case VertexAttribType::GL_UNSIGNED_BYTE: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_UNSIGNED_BYTE))) ? (1) :
                        /* case VertexAttribType::GL_SHORT: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_SHORT))) ? (2) :
                        /* case VertexAttribType::GL_UNSIGNED_SHORT: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_UNSIGNED_SHORT))) ? (2) :
                        /* case VertexAttribType::GL_FIXED: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_FIXED))) ? (4) :
                        /* case VertexAttribType::GL_FLOAT: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_FLOAT))) ? (4) :
                        /* case VertexAttribType::GL_ARB_half_float_vertex: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_ARB_half_float_vertex))) ? (2) :
                        /* case VertexAttribType::GL_HALF_FLOAT_OES: */(((l_vertexAttribTypeSize_117_t) == (VertexAttribType::GL_HALF_FLOAT_OES))) ? (2) :
                        /* default: */ 0 /* clang-format on */;
                    uint32_t l_elsize = l_vertexAttribTypeSize_117_result * l_arr->mSize;
                    uint32_t l_elstride = /* clang-format off */
                    /* switch(l_arr->mStride == 0) */
                        /* case true: */(((l_arr->mStride == 0) == (true))) ? (l_elsize) :
                        /* case false: */(((l_arr->mStride == 0) == (false))) ? ((uint32_t)(l_arr->mStride)) :
                        /* default: */ 0 /* clang-format on */;
                    for (uint32_t l_v = l_ReadVertexArrays_116_first_index;
                         l_v < l_ReadVertexArrays_116_last_index + 1; ++l_v) {
                        uint32_t l_offset = l_elstride * l_v;
                        read(slice(l_arr->mPointer, (uint64_t)(l_offset),
                                   (uint64_t)(l_offset + l_elsize)));
                    }
                }
            }
            uint32_t l_IndexSize_118_indices_type = indices_type;
            uint32_t l_IndexSize_118_result = /* clang-format off */
            /* switch(l_IndexSize_118_indices_type) */
                /* case IndicesType::GL_UNSIGNED_BYTE: */(((l_IndexSize_118_indices_type) == (IndicesType::GL_UNSIGNED_BYTE))) ? (1) :
                /* case IndicesType::GL_UNSIGNED_SHORT: */(((l_IndexSize_118_indices_type) == (IndicesType::GL_UNSIGNED_SHORT))) ? (2) :
                /* case IndicesType::GL_UNSIGNED_INT: */(((l_IndexSize_118_indices_type) == (IndicesType::GL_UNSIGNED_INT))) ? (4) :
                /* default: */ 0 /* clang-format on */;
            read(slice(l_index_data, (uint64_t)(0),
                       (uint64_t)((uint32_t)(element_count)*l_IndexSize_118_result)));
        }
    } while (false);

    mEncoder->Uint16(168);  // Type ID -- TODO: mEncoder->Id(GL_DRAW_ELEMENTS_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(draw_mode));
    mEncoder->Int32(element_count);
    mEncoder->Uint32(static_cast<uint32_t>(indices_type));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(indices));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glDrawArrays(uint32_t draw_mode, int32_t first_index, int32_t index_count) {
    GAPID_INFO("glDrawArrays()\n");
    mImports.glDrawArrays(draw_mode, first_index, index_count);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_119_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_119_result;
        int32_t l_last_index = first_index + index_count - 1;
        std::shared_ptr<Context> l_ReadVertexArrays_120_ctx = l_ctx;
        uint32_t l_ReadVertexArrays_120_first_index = (uint32_t)(first_index);
        uint32_t l_ReadVertexArrays_120_last_index = (uint32_t)(l_last_index);
        for (int32_t l_i = 0; l_i < l_ReadVertexArrays_120_ctx->mVertexAttributeArrays.size();
             ++l_i) {
            std::shared_ptr<VertexAttributeArray> l_arr =
                    l_ReadVertexArrays_120_ctx->mVertexAttributeArrays[(AttributeLocation)(l_i)];
            if (l_arr->mEnabled && l_arr->mBuffer == (BufferId)(0)) {
                uint32_t l_vertexAttribTypeSize_121_t = l_arr->mType;
                uint32_t l_vertexAttribTypeSize_121_result = /* clang-format off */
                /* switch(l_vertexAttribTypeSize_121_t) */
                    /* case VertexAttribType::GL_BYTE: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_BYTE))) ? (1) :
                    /* case VertexAttribType::GL_UNSIGNED_BYTE: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_UNSIGNED_BYTE))) ? (1) :
                    /* case VertexAttribType::GL_SHORT: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_SHORT))) ? (2) :
                    /* case VertexAttribType::GL_UNSIGNED_SHORT: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_UNSIGNED_SHORT))) ? (2) :
                    /* case VertexAttribType::GL_FIXED: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_FIXED))) ? (4) :
                    /* case VertexAttribType::GL_FLOAT: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_FLOAT))) ? (4) :
                    /* case VertexAttribType::GL_ARB_half_float_vertex: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_ARB_half_float_vertex))) ? (2) :
                    /* case VertexAttribType::GL_HALF_FLOAT_OES: */(((l_vertexAttribTypeSize_121_t) == (VertexAttribType::GL_HALF_FLOAT_OES))) ? (2) :
                    /* default: */ 0 /* clang-format on */;
                uint32_t l_elsize = l_vertexAttribTypeSize_121_result * l_arr->mSize;
                uint32_t l_elstride = /* clang-format off */
                /* switch(l_arr->mStride == 0) */
                    /* case true: */(((l_arr->mStride == 0) == (true))) ? (l_elsize) :
                    /* case false: */(((l_arr->mStride == 0) == (false))) ? ((uint32_t)(l_arr->mStride)) :
                    /* default: */ 0 /* clang-format on */;
                for (uint32_t l_v = l_ReadVertexArrays_120_first_index;
                     l_v < l_ReadVertexArrays_120_last_index + 1; ++l_v) {
                    uint32_t l_offset = l_elstride * l_v;
                    read(slice(l_arr->mPointer, (uint64_t)(l_offset),
                               (uint64_t)(l_offset + l_elsize)));
                }
            }
        }
    } while (false);

    mEncoder->Uint16(169);  // Type ID -- TODO: mEncoder->Id(GL_DRAW_ARRAYS_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(draw_mode));
    mEncoder->Int32(first_index);
    mEncoder->Int32(index_count);
}

inline void GlesSpy::glFlush() {
    GAPID_INFO("glFlush()\n");
    mImports.glFlush();

    do {
    } while (false);

    mEncoder->Uint16(170);  // Type ID -- TODO: mEncoder->Id(GL_FLUSH_ID);
    encodeObservations();
}

inline void GlesSpy::glFinish() {
    GAPID_INFO("glFinish()\n");
    mImports.glFinish();

    do {
    } while (false);

    mEncoder->Uint16(171);  // Type ID -- TODO: mEncoder->Id(GL_FINISH_ID);
    encodeObservations();
}

inline void GlesSpy::glGetBooleanv(uint32_t param, bool* values) {
    GAPID_INFO("glGetBooleanv()\n");
    mImports.glGetBooleanv(param, values);

    do {
        Slice<bool> l_v = slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param)));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_122_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_122_result;
        switch (param) {
            case StateVariable::GL_BLEND: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_BLEND]);
                break;
            }
            case StateVariable::GL_CULL_FACE: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_CULL_FACE]);
                break;
            }
            case StateVariable::GL_DEPTH_TEST: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_DEPTH_TEST]);
                break;
            }
            case StateVariable::GL_DITHER: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_DITHER]);
                break;
            }
            case StateVariable::GL_POLYGON_OFFSET_FILL: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_POLYGON_OFFSET_FILL]);
                break;
            }
            case StateVariable::GL_SAMPLE_ALPHA_TO_COVERAGE: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_SAMPLE_ALPHA_TO_COVERAGE]);
                break;
            }
            case StateVariable::GL_SAMPLE_COVERAGE: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_SAMPLE_COVERAGE]);
                break;
            }
            case StateVariable::GL_SCISSOR_TEST: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_SCISSOR_TEST]);
                break;
            }
            case StateVariable::GL_STENCIL_TEST: {
                write(l_v, 0, l_ctx->mCapabilities[Capability::GL_STENCIL_TEST]);
                break;
            }
            case StateVariable::GL_DEPTH_WRITEMASK: {
                write(l_v, 0, l_ctx->mRasterizing.mDepthMask);
                break;
            }
            case StateVariable::GL_COLOR_WRITEMASK: {
                write(l_v, 0, l_ctx->mRasterizing.mColorMaskRed);
                write(l_v, 1, l_ctx->mRasterizing.mColorMaskGreen);
                write(l_v, 2, l_ctx->mRasterizing.mColorMaskBlue);
                write(l_v, 3, l_ctx->mRasterizing.mColorMaskAlpha);
                break;
            }
            case StateVariable::GL_SAMPLE_COVERAGE_INVERT: {
                write(l_v, 0, l_ctx->mRasterizing.mSampleCoverageInvert);
                break;
            }
            case StateVariable::GL_SHADER_COMPILER: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(172);  // Type ID -- TODO: mEncoder->Id(GL_GET_BOOLEANV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(param));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetFloatv(uint32_t param, float* values) {
    GAPID_INFO("glGetFloatv()\n");
    mImports.glGetFloatv(param, values);

    do {
        Slice<float> l_v = slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param)));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_123_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_123_result;
        switch (param) {
            case StateVariable::GL_DEPTH_RANGE: {
                write(l_v, 0, l_ctx->mRasterizing.mDepthNear);
                write(l_v, 1, l_ctx->mRasterizing.mDepthFar);
                break;
            }
            case StateVariable::GL_LINE_WIDTH: {
                write(l_v, 0, l_ctx->mRasterizing.mLineWidth);
                break;
            }
            case StateVariable::GL_POLYGON_OFFSET_FACTOR: {
                write(l_v, 0, l_ctx->mRasterizing.mPolygonOffsetFactor);
                break;
            }
            case StateVariable::GL_POLYGON_OFFSET_UNITS: {
                write(l_v, 0, l_ctx->mRasterizing.mPolygonOffsetUnits);
                break;
            }
            case StateVariable::GL_SAMPLE_COVERAGE_VALUE: {
                write(l_v, 0, l_ctx->mRasterizing.mSampleCoverageValue);
                break;
            }
            case StateVariable::GL_COLOR_CLEAR_VALUE: {
                write(l_v, 0, l_ctx->mClearing.mClearColor.mRed);
                write(l_v, 1, l_ctx->mClearing.mClearColor.mGreen);
                write(l_v, 2, l_ctx->mClearing.mClearColor.mBlue);
                write(l_v, 3, l_ctx->mClearing.mClearColor.mAlpha);
                break;
            }
            case StateVariable::GL_DEPTH_CLEAR_VALUE: {
                write(l_v, 0, l_ctx->mClearing.mClearDepth);
                break;
            }
            case StateVariable::GL_ALIASED_LINE_WIDTH_RANGE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                write(l_v, 1,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 1));
                break;
            }
            case StateVariable::GL_ALIASED_POINT_SIZE_RANGE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                write(l_v, 1,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 1));
                break;
            }
            case StateVariable::GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(173);  // Type ID -- TODO: mEncoder->Id(GL_GET_FLOATV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(param));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetIntegerv(uint32_t param, int32_t* values) {
    GAPID_INFO("glGetIntegerv()\n");
    mImports.glGetIntegerv(param, values);

    do {
        Slice<int32_t> l_v = slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param)));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_124_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_124_result;
        switch (param) {
            case StateVariable::GL_ACTIVE_TEXTURE: {
                write(l_v, 0, (int32_t)(l_ctx->mActiveTextureUnit));
                break;
            }
            case StateVariable::GL_ARRAY_BUFFER_BINDING: {
                write(l_v, 0, (int32_t)(l_ctx->mBoundBuffers[BufferTarget::GL_ARRAY_BUFFER]));
                break;
            }
            case StateVariable::GL_ELEMENT_ARRAY_BUFFER_BINDING: {
                write(l_v, 0,
                      (int32_t)(l_ctx->mBoundBuffers[BufferTarget::GL_ELEMENT_ARRAY_BUFFER]));
                break;
            }
            case StateVariable::GL_BLEND_SRC_ALPHA: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mSrcAlphaBlendFactor));
                break;
            }
            case StateVariable::GL_BLEND_SRC_RGB: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mSrcRgbBlendFactor));
                break;
            }
            case StateVariable::GL_BLEND_DST_ALPHA: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mDstAlphaBlendFactor));
                break;
            }
            case StateVariable::GL_BLEND_DST_RGB: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mDstRgbBlendFactor));
                break;
            }
            case StateVariable::GL_BLEND_EQUATION_RGB: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mBlendEquationRgb));
                break;
            }
            case StateVariable::GL_BLEND_EQUATION_ALPHA: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mBlendEquationAlpha));
                break;
            }
            case StateVariable::GL_BLEND_COLOR: {
                write(l_v, 0, (int32_t)(l_ctx->mBlending.mBlendColor.mRed));
                write(l_v, 1, (int32_t)(l_ctx->mBlending.mBlendColor.mGreen));
                write(l_v, 2, (int32_t)(l_ctx->mBlending.mBlendColor.mBlue));
                write(l_v, 3, (int32_t)(l_ctx->mBlending.mBlendColor.mAlpha));
                break;
            }
            case StateVariable::GL_DEPTH_FUNC: {
                write(l_v, 0, (int32_t)(l_ctx->mRasterizing.mDepthTestFunction));
                break;
            }
            case StateVariable::GL_DEPTH_CLEAR_VALUE: {
                write(l_v, 0, (int32_t)(l_ctx->mClearing.mClearDepth));
                break;
            }
            case StateVariable::GL_STENCIL_WRITEMASK: {
                write(l_v, 0, (int32_t)(l_ctx->mRasterizing.mStencilMask[FaceMode::GL_FRONT]));
                break;
            }
            case StateVariable::GL_STENCIL_BACK_WRITEMASK: {
                write(l_v, 0, (int32_t)(l_ctx->mRasterizing.mStencilMask[FaceMode::GL_BACK]));
                break;
            }
            case StateVariable::GL_VIEWPORT: {
                write(l_v, 0, l_ctx->mRasterizing.mViewport.mX);
                write(l_v, 1, l_ctx->mRasterizing.mViewport.mY);
                write(l_v, 2, l_ctx->mRasterizing.mViewport.mWidth);
                write(l_v, 3, l_ctx->mRasterizing.mViewport.mHeight);
                break;
            }
            case StateVariable::GL_SCISSOR_BOX: {
                write(l_v, 0, l_ctx->mRasterizing.mScissor.mX);
                write(l_v, 1, l_ctx->mRasterizing.mScissor.mY);
                write(l_v, 2, l_ctx->mRasterizing.mScissor.mWidth);
                write(l_v, 3, l_ctx->mRasterizing.mScissor.mHeight);
                break;
            }
            case StateVariable::GL_FRONT_FACE: {
                write(l_v, 0, (int32_t)(l_ctx->mRasterizing.mFrontFace));
                break;
            }
            case StateVariable::GL_CULL_FACE_MODE: {
                write(l_v, 0, (int32_t)(l_ctx->mRasterizing.mCullFace));
                break;
            }
            case StateVariable::GL_STENCIL_CLEAR_VALUE: {
                write(l_v, 0, l_ctx->mClearing.mClearStencil);
                break;
            }
            case StateVariable::GL_FRAMEBUFFER_BINDING: {
                write(l_v, 0,
                      (int32_t)(l_ctx->mBoundFramebuffers[FramebufferTarget::GL_FRAMEBUFFER]));
                break;
            }
            case StateVariable::GL_READ_FRAMEBUFFER_BINDING: {
                write(l_v, 0,
                      (int32_t)(l_ctx->mBoundFramebuffers[FramebufferTarget::GL_READ_FRAMEBUFFER]));
                break;
            }
            case StateVariable::GL_RENDERBUFFER_BINDING: {
                write(l_v, 0,
                      (int32_t)(l_ctx->mBoundRenderbuffers[RenderbufferTarget::GL_RENDERBUFFER]));
                break;
            }
            case StateVariable::GL_CURRENT_PROGRAM: {
                write(l_v, 0, (int32_t)(l_ctx->mBoundProgram));
                break;
            }
            case StateVariable::GL_TEXTURE_BINDING_2D: {
                write(l_v, 0, (int32_t)(l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                            [TextureTarget::GL_TEXTURE_2D]));
                break;
            }
            case StateVariable::GL_TEXTURE_BINDING_CUBE_MAP: {
                write(l_v, 0, (int32_t)(l_ctx->mTextureUnits[l_ctx->mActiveTextureUnit]
                                                            [TextureTarget::GL_TEXTURE_CUBE_MAP]));
                break;
            }
            case StateVariable::GL_GENERATE_MIPMAP_HINT: {
                write(l_v, 0, (int32_t)(l_ctx->mGenerateMipmapHint));
                break;
            }
            case StateVariable::GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_CUBE_MAP_TEXTURE_SIZE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_FRAGMENT_UNIFORM_VECTORS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_RENDERBUFFER_SIZE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_TEXTURE_IMAGE_UNITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_TEXTURE_SIZE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_VARYING_VECTORS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_VERTEX_ATTRIBS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_VERTEX_UNIFORM_VECTORS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_VIEWPORT_DIMS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                write(l_v, 1,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 1));
                break;
            }
            case StateVariable::GL_NUM_COMPRESSED_TEXTURE_FORMATS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_NUM_SHADER_BINARY_FORMATS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_PACK_ALIGNMENT: {
                write(l_v, 0, l_ctx->mPixelStorage[PixelStoreParameter::GL_PACK_ALIGNMENT]);
                break;
            }
            case StateVariable::GL_UNPACK_ALIGNMENT: {
                write(l_v, 0, l_ctx->mPixelStorage[PixelStoreParameter::GL_UNPACK_ALIGNMENT]);
                break;
            }
            case StateVariable::GL_ALPHA_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_BLUE_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_GREEN_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_RED_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_DEPTH_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_SAMPLE_BUFFERS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_SAMPLES: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_STENCIL_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_SUBPIXEL_BITS: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_IMPLEMENTATION_COLOR_READ_FORMAT: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_IMPLEMENTATION_COLOR_READ_TYPE: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
            case StateVariable::GL_GPU_DISJOINT_EXT: {
                write(l_v, 0,
                      read(slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))), 0));
                break;
            }
        }
    } while (false);

    mEncoder->Uint16(174);  // Type ID -- TODO: mEncoder->Id(GL_GET_INTEGERV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(param));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(values));
    mEncoder->Uint32(0);  // PoolID
}

inline char* GlesSpy::glGetString(uint32_t param) {
    GAPID_INFO("glGetString()\n");
    char* result = mImports.glGetString(param);

    do {
        break;
    } while (false);

    mEncoder->Uint16(175);  // Type ID -- TODO: mEncoder->Id(GL_GET_STRING_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(param));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline void GlesSpy::glEnable(uint32_t capability) {
    GAPID_INFO("glEnable()\n");
    mImports.glEnable(capability);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_125_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_125_result;
        l_ctx->mCapabilities[capability] = true;
    } while (false);

    mEncoder->Uint16(176);  // Type ID -- TODO: mEncoder->Id(GL_ENABLE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(capability));
}

inline void GlesSpy::glDisable(uint32_t capability) {
    GAPID_INFO("glDisable()\n");
    mImports.glDisable(capability);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_126_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_126_result;
        l_ctx->mCapabilities[capability] = false;
    } while (false);

    mEncoder->Uint16(177);  // Type ID -- TODO: mEncoder->Id(GL_DISABLE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(capability));
}

inline bool GlesSpy::glIsEnabled(uint32_t capability) {
    GAPID_INFO("glIsEnabled()\n");
    bool result = mImports.glIsEnabled(capability);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_127_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_127_result;
        break;
    } while (false);

    mEncoder->Uint16(178);  // Type ID -- TODO: mEncoder->Id(GL_IS_ENABLED_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(capability));
    mEncoder->Bool(result);

    return result;
}

inline void* GlesSpy::glMapBufferRange(uint32_t target, int32_t offset, int32_t length,
                                       uint32_t access) {
    GAPID_INFO("glMapBufferRange()\n");
    void* result = mImports.glMapBufferRange(target, offset, length, access);

    do {
        break;
    } while (false);

    mEncoder->Uint16(179);  // Type ID -- TODO: mEncoder->Id(GL_MAP_BUFFER_RANGE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(offset);
    mEncoder->Int32(length);
    mEncoder->Uint32(static_cast<uint32_t>(access));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(result));
    mEncoder->Uint32(0);  // PoolID

    return result;
}

inline void GlesSpy::glUnmapBuffer(uint32_t target) {
    GAPID_INFO("glUnmapBuffer()\n");
    mImports.glUnmapBuffer(target);

    do {
    } while (false);

    mEncoder->Uint16(180);  // Type ID -- TODO: mEncoder->Id(GL_UNMAP_BUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
}

inline void GlesSpy::glInvalidateFramebuffer(uint32_t target, int32_t count,
                                             uint32_t* attachments) {
    GAPID_INFO("glInvalidateFramebuffer()\n");
    mImports.glInvalidateFramebuffer(target, count, attachments);

    do {
    } while (false);

    mEncoder->Uint16(181);  // Type ID -- TODO: mEncoder->Id(GL_INVALIDATE_FRAMEBUFFER_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(attachments));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glRenderbufferStorageMultisample(uint32_t target, int32_t samples,
                                                      uint32_t format, int32_t width,
                                                      int32_t height) {
    GAPID_INFO("glRenderbufferStorageMultisample()\n");
    mImports.glRenderbufferStorageMultisample(target, samples, format, width, height);

    do {
    } while (false);

    mEncoder->Uint16(
            182);  // Type ID -- TODO: mEncoder->Id(GL_RENDERBUFFER_STORAGE_MULTISAMPLE_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Int32(samples);
    mEncoder->Uint32(static_cast<uint32_t>(format));
    mEncoder->Int32(width);
    mEncoder->Int32(height);
}

inline void GlesSpy::glBlitFramebuffer(int32_t srcX0, int32_t srcY0, int32_t srcX1, int32_t srcY1,
                                       int32_t dstX0, int32_t dstY0, int32_t dstX1, int32_t dstY1,
                                       uint32_t mask, uint32_t filter) {
    GAPID_INFO("glBlitFramebuffer()\n");
    mImports.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
                               filter);

    do {
    } while (false);

    mEncoder->Uint16(183);  // Type ID -- TODO: mEncoder->Id(GL_BLIT_FRAMEBUFFER_ID);
    encodeObservations();
    mEncoder->Int32(srcX0);
    mEncoder->Int32(srcY0);
    mEncoder->Int32(srcX1);
    mEncoder->Int32(srcY1);
    mEncoder->Int32(dstX0);
    mEncoder->Int32(dstY0);
    mEncoder->Int32(dstX1);
    mEncoder->Int32(dstY1);
    mEncoder->Uint32(static_cast<uint32_t>(mask));
    mEncoder->Uint32(static_cast<uint32_t>(filter));
}

inline void GlesSpy::glGenQueries(int32_t count, uint32_t* queries) {
    GAPID_INFO("glGenQueries()\n");
    mImports.glGenQueries(count, queries);

    do {
        Slice<QueryId> l_q = slice(queries, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_128_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_128_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            QueryId l_id = (QueryId)(
                    read(slice(queries, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mQueries[l_id] = std::shared_ptr<Query>((new Query()));
            write(l_q, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(184);  // Type ID -- TODO: mEncoder->Id(GL_GEN_QUERIES_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(queries));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBeginQuery(uint32_t target, uint32_t query) {
    GAPID_INFO("glBeginQuery()\n");
    mImports.glBeginQuery(target, query);

    do {
    } while (false);

    mEncoder->Uint16(185);  // Type ID -- TODO: mEncoder->Id(GL_BEGIN_QUERY_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(query);
}

inline void GlesSpy::glEndQuery(uint32_t target) {
    GAPID_INFO("glEndQuery()\n");
    mImports.glEndQuery(target);

    do {
    } while (false);

    mEncoder->Uint16(186);  // Type ID -- TODO: mEncoder->Id(GL_END_QUERY_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
}

inline void GlesSpy::glDeleteQueries(int32_t count, uint32_t* queries) {
    GAPID_INFO("glDeleteQueries()\n");
    mImports.glDeleteQueries(count, queries);

    do {
        Slice<QueryId> l_q = slice(queries, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_129_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_129_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mQueries[read(l_q, (uint64_t)(l_i))] = std::shared_ptr<Query>();
        }
    } while (false);

    mEncoder->Uint16(187);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_QUERIES_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(queries));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsQuery(uint32_t query) {
    GAPID_INFO("glIsQuery()\n");
    bool result = mImports.glIsQuery(query);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_130_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_130_result;
        break;
    } while (false);

    mEncoder->Uint16(188);  // Type ID -- TODO: mEncoder->Id(GL_IS_QUERY_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetQueryiv()\n");
    mImports.glGetQueryiv(target, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(189);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERYIV_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetQueryObjectuiv(uint32_t query, uint32_t parameter, uint32_t* value) {
    GAPID_INFO("glGetQueryObjectuiv()\n");
    mImports.glGetQueryObjectuiv(query, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(190);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERY_OBJECTUIV_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGenQueriesEXT(int32_t count, uint32_t* queries) {
    GAPID_INFO("glGenQueriesEXT()\n");
    mImports.glGenQueriesEXT(count, queries);

    do {
        Slice<QueryId> l_q = slice(queries, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_131_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_131_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            QueryId l_id = (QueryId)(
                    read(slice(queries, (uint64_t)(0), (uint64_t)(count)), (uint64_t)(l_i)));
            l_ctx->mInstances.mQueries[l_id] = std::shared_ptr<Query>((new Query()));
            write(l_q, (uint64_t)(l_i), l_id);
        }
    } while (false);

    mEncoder->Uint16(191);  // Type ID -- TODO: mEncoder->Id(GL_GEN_QUERIES_E_X_T_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(queries));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glBeginQueryEXT(uint32_t target, uint32_t query) {
    GAPID_INFO("glBeginQueryEXT()\n");
    mImports.glBeginQueryEXT(target, query);

    do {
    } while (false);

    mEncoder->Uint16(192);  // Type ID -- TODO: mEncoder->Id(GL_BEGIN_QUERY_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(query);
}

inline void GlesSpy::glEndQueryEXT(uint32_t target) {
    GAPID_INFO("glEndQueryEXT()\n");
    mImports.glEndQueryEXT(target);

    do {
    } while (false);

    mEncoder->Uint16(193);  // Type ID -- TODO: mEncoder->Id(GL_END_QUERY_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
}

inline void GlesSpy::glDeleteQueriesEXT(int32_t count, uint32_t* queries) {
    GAPID_INFO("glDeleteQueriesEXT()\n");
    mImports.glDeleteQueriesEXT(count, queries);

    do {
        Slice<QueryId> l_q = slice(queries, (uint64_t)(0), (uint64_t)(count));
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_132_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_132_result;
        for (int32_t l_i = 0; l_i < count; ++l_i) {
            l_ctx->mInstances.mQueries[read(l_q, (uint64_t)(l_i))] = std::shared_ptr<Query>();
        }
    } while (false);

    mEncoder->Uint16(194);  // Type ID -- TODO: mEncoder->Id(GL_DELETE_QUERIES_E_X_T_ID);
    encodeObservations();
    mEncoder->Int32(count);
    mEncoder->Uint64(reinterpret_cast<uint64_t>(queries));
    mEncoder->Uint32(0);  // PoolID
}

inline bool GlesSpy::glIsQueryEXT(uint32_t query) {
    GAPID_INFO("glIsQueryEXT()\n");
    bool result = mImports.glIsQueryEXT(query);

    do {
        std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread];
        std::shared_ptr<Context> l_GetContext_133_result = l_context;
        std::shared_ptr<Context> l_ctx = l_GetContext_133_result;
        break;
    } while (false);

    mEncoder->Uint16(195);  // Type ID -- TODO: mEncoder->Id(GL_IS_QUERY_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Bool(result);

    return result;
}

inline void GlesSpy::glQueryCounterEXT(uint32_t query, uint32_t target) {
    GAPID_INFO("glQueryCounterEXT()\n");
    mImports.glQueryCounterEXT(query, target);

    do {
    } while (false);

    mEncoder->Uint16(196);  // Type ID -- TODO: mEncoder->Id(GL_QUERY_COUNTER_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(target));
}

inline void GlesSpy::glGetQueryivEXT(uint32_t target, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetQueryivEXT()\n");
    mImports.glGetQueryivEXT(target, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(197);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERYIV_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(static_cast<uint32_t>(target));
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetQueryObjectivEXT(uint32_t query, uint32_t parameter, int32_t* value) {
    GAPID_INFO("glGetQueryObjectivEXT()\n");
    mImports.glGetQueryObjectivEXT(query, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(198);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERY_OBJECTIV_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetQueryObjectuivEXT(uint32_t query, uint32_t parameter, uint32_t* value) {
    GAPID_INFO("glGetQueryObjectuivEXT()\n");
    mImports.glGetQueryObjectuivEXT(query, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(199);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERY_OBJECTUIV_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetQueryObjecti64vEXT(uint32_t query, uint32_t parameter, int64_t* value) {
    GAPID_INFO("glGetQueryObjecti64vEXT()\n");
    mImports.glGetQueryObjecti64vEXT(query, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(200);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERY_OBJECTI64V_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

inline void GlesSpy::glGetQueryObjectui64vEXT(uint32_t query, uint32_t parameter, uint64_t* value) {
    GAPID_INFO("glGetQueryObjectui64vEXT()\n");
    mImports.glGetQueryObjectui64vEXT(query, parameter, value);

    do {
        write(slice(value, 0, 1), 0, read(slice(value, 0, 1), 0));
    } while (false);

    mEncoder->Uint16(201);  // Type ID -- TODO: mEncoder->Id(GL_GET_QUERY_OBJECTUI64V_E_X_T_ID);
    encodeObservations();
    mEncoder->Uint32(query);
    mEncoder->Uint32(static_cast<uint32_t>(parameter));
    mEncoder->Uint64(reinterpret_cast<uint64_t>(value));
    mEncoder->Uint32(0);  // PoolID
}

}  // namespace gapii

#endif  // GAPII_GLES_SPY_H