// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml.
//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Context_gl.cpp: Implements the GL specific parts of Context.

#include "Context.h"
#include "common/debug.h"

namespace gl
{

void Context::compressedTexImage1D(GLenum target,
                                   GLint level,
                                   GLenum internalformat,
                                   GLsizei width,
                                   GLint border,
                                   GLsizei imageSize,
                                   const void *data)
{
    UNIMPLEMENTED();
}

void Context::compressedTexSubImage1D(GLenum target,
                                      GLint level,
                                      GLint xoffset,
                                      GLsizei width,
                                      GLenum format,
                                      GLsizei imageSize,
                                      const void *data)
{
    UNIMPLEMENTED();
}

void Context::getCompressedTexImage(GLenum target, GLint level, void *img)
{
    UNIMPLEMENTED();
}

void Context::loadTransposeMatrixd(const GLdouble *m)
{
    UNIMPLEMENTED();
}

void Context::loadTransposeMatrixf(const GLfloat *m)
{
    UNIMPLEMENTED();
}

void Context::multTransposeMatrixd(const GLdouble *m)
{
    UNIMPLEMENTED();
}

void Context::multTransposeMatrixf(const GLfloat *m)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1d(GLenum target, GLdouble s)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1dv(GLenum target, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1f(GLenum target, GLfloat s)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1fv(GLenum target, const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1i(GLenum target, GLint s)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1iv(GLenum target, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1s(GLenum target, GLshort s)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord1sv(GLenum target, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2dv(GLenum target, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2fv(GLenum target, const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2i(GLenum target, GLint s, GLint t)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2iv(GLenum target, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2s(GLenum target, GLshort s, GLshort t)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord2sv(GLenum target, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3dv(GLenum target, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3fv(GLenum target, const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3iv(GLenum target, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord3sv(GLenum target, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4dv(GLenum target, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4fv(GLenum target, const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4iv(GLenum target, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
    UNIMPLEMENTED();
}

void Context::multiTexCoord4sv(GLenum target, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::getVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib1d(GLuint index, GLdouble x)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib1dv(GLuint index, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib1s(GLuint index, GLshort x)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib1sv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib2dv(GLuint index, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib2sv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib3dv(GLuint index, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib3sv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Niv(GLuint index, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nsv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4Nusv(GLuint index, const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4bv(GLuint index, const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4dv(GLuint index, const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4iv(GLuint index, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4sv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4ubv(GLuint index, const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4uiv(GLuint index, const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttrib4usv(GLuint index, const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::beginConditionalRender(GLuint id, GLenum mode)
{
    UNIMPLEMENTED();
}

void Context::clampColor(GLenum target, GLenum clamp)
{
    UNIMPLEMENTED();
}

void Context::colorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
    UNIMPLEMENTED();
}

void Context::disablei(GLenum target, GLuint index)
{
    UNIMPLEMENTED();
}

void Context::enablei(GLenum target, GLuint index)
{
    UNIMPLEMENTED();
}

void Context::endConditionalRender()
{
    UNIMPLEMENTED();
}

void Context::framebufferTexture1D(GLenum target,
                                   GLenum attachment,
                                   GLenum textarget,
                                   GLuint texture,
                                   GLint level)
{
    UNIMPLEMENTED();
}

GLboolean Context::isEnabledi(GLenum target, GLuint index)
{
    UNIMPLEMENTED();
    return false;
}

void Context::vertexAttribI1i(GLuint index, GLint x)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI1iv(GLuint index, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI1ui(GLuint index, GLuint x)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI1uiv(GLuint index, const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI2i(GLuint index, GLint x, GLint y)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI2iv(GLuint index, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI2uiv(GLuint index, const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI3iv(GLuint index, const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI3uiv(GLuint index, const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI4bv(GLuint index, const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI4sv(GLuint index, const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI4ubv(GLuint index, const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::vertexAttribI4usv(GLuint index, const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::getActiveUniformName(GLuint program,
                                   GLuint uniformIndex,
                                   GLsizei bufSize,
                                   GLsizei *length,
                                   GLchar *uniformName)
{
    UNIMPLEMENTED();
}

void Context::primitiveRestartIndex(GLuint index)
{
    UNIMPLEMENTED();
}

void Context::texBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
    UNIMPLEMENTED();
}

void Context::fogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
{
    UNIMPLEMENTED();
}

void Context::fogCoordd(GLdouble coord)
{
    UNIMPLEMENTED();
}

void Context::fogCoorddv(const GLdouble *coord)
{
    UNIMPLEMENTED();
}

void Context::fogCoordf(GLfloat coord)
{
    UNIMPLEMENTED();
}

void Context::fogCoordfv(const GLfloat *coord)
{
    UNIMPLEMENTED();
}

void Context::pointParameteri(GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::pointParameteriv(GLenum pname, const GLint *params)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3bv(const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3i(GLint red, GLint green, GLint blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3s(GLshort red, GLshort green, GLshort blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3ubv(const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3ui(GLuint red, GLuint green, GLuint blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3uiv(const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3us(GLushort red, GLushort green, GLushort blue)
{
    UNIMPLEMENTED();
}

void Context::secondaryColor3usv(const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::secondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
    UNIMPLEMENTED();
}

void Context::windowPos2d(GLdouble x, GLdouble y)
{
    UNIMPLEMENTED();
}

void Context::windowPos2dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos2f(GLfloat x, GLfloat y)
{
    UNIMPLEMENTED();
}

void Context::windowPos2fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos2i(GLint x, GLint y)
{
    UNIMPLEMENTED();
}

void Context::windowPos2iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos2s(GLshort x, GLshort y)
{
    UNIMPLEMENTED();
}

void Context::windowPos2sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::windowPos3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    UNIMPLEMENTED();
}

void Context::windowPos3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos3i(GLint x, GLint y, GLint z)
{
    UNIMPLEMENTED();
}

void Context::windowPos3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::windowPos3s(GLshort x, GLshort y, GLshort z)
{
    UNIMPLEMENTED();
}

void Context::windowPos3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::getBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
{
    UNIMPLEMENTED();
}

void Context::accum(GLenum op, GLfloat value)
{
    UNIMPLEMENTED();
}

void Context::begin(GLenum mode)
{
    UNIMPLEMENTED();
}

void Context::bitmap(GLsizei width,
                     GLsizei height,
                     GLfloat xorig,
                     GLfloat yorig,
                     GLfloat xmove,
                     GLfloat ymove,
                     const GLubyte *bitmap)
{
    UNIMPLEMENTED();
}

void Context::callList(GLuint list)
{
    UNIMPLEMENTED();
}

void Context::callLists(GLsizei n, GLenum type, const void *lists)
{
    UNIMPLEMENTED();
}

void Context::clearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    UNIMPLEMENTED();
}

void Context::clearDepth(GLdouble depth)
{
    UNIMPLEMENTED();
}

void Context::clearIndex(GLfloat c)
{
    UNIMPLEMENTED();
}

void Context::clipPlane(GLenum plane, const GLdouble *equation)
{
    UNIMPLEMENTED();
}

void Context::color3b(GLbyte red, GLbyte green, GLbyte blue)
{
    UNIMPLEMENTED();
}

void Context::color3bv(const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::color3d(GLdouble red, GLdouble green, GLdouble blue)
{
    UNIMPLEMENTED();
}

void Context::color3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::color3f(GLfloat red, GLfloat green, GLfloat blue)
{
    UNIMPLEMENTED();
}

void Context::color3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::color3i(GLint red, GLint green, GLint blue)
{
    UNIMPLEMENTED();
}

void Context::color3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::color3s(GLshort red, GLshort green, GLshort blue)
{
    UNIMPLEMENTED();
}

void Context::color3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::color3ub(GLubyte red, GLubyte green, GLubyte blue)
{
    UNIMPLEMENTED();
}

void Context::color3ubv(const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::color3ui(GLuint red, GLuint green, GLuint blue)
{
    UNIMPLEMENTED();
}

void Context::color3uiv(const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::color3us(GLushort red, GLushort green, GLushort blue)
{
    UNIMPLEMENTED();
}

void Context::color3usv(const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
    UNIMPLEMENTED();
}

void Context::color4bv(const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
    UNIMPLEMENTED();
}

void Context::color4dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::color4fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::color4i(GLint red, GLint green, GLint blue, GLint alpha)
{
    UNIMPLEMENTED();
}

void Context::color4iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
    UNIMPLEMENTED();
}

void Context::color4sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::color4ubv(const GLubyte *v)
{
    UNIMPLEMENTED();
}

void Context::color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
    UNIMPLEMENTED();
}

void Context::color4uiv(const GLuint *v)
{
    UNIMPLEMENTED();
}

void Context::color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
    UNIMPLEMENTED();
}

void Context::color4usv(const GLushort *v)
{
    UNIMPLEMENTED();
}

void Context::colorMaterial(GLenum face, GLenum mode)
{
    UNIMPLEMENTED();
}

void Context::copyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
    UNIMPLEMENTED();
}

void Context::deleteLists(GLuint list, GLsizei range)
{
    UNIMPLEMENTED();
}

void Context::depthRange(GLdouble n, GLdouble f)
{
    UNIMPLEMENTED();
}

void Context::drawBuffer(GLenum buf)
{
    UNIMPLEMENTED();
}

void Context::drawPixels(GLsizei width,
                         GLsizei height,
                         GLenum format,
                         GLenum type,
                         const void *pixels)
{
    UNIMPLEMENTED();
}

void Context::edgeFlag(GLboolean flag)
{
    UNIMPLEMENTED();
}

void Context::edgeFlagv(const GLboolean *flag)
{
    UNIMPLEMENTED();
}

void Context::end()
{
    UNIMPLEMENTED();
}

void Context::endList()
{
    UNIMPLEMENTED();
}

void Context::evalCoord1d(GLdouble u)
{
    UNIMPLEMENTED();
}

void Context::evalCoord1dv(const GLdouble *u)
{
    UNIMPLEMENTED();
}

void Context::evalCoord1f(GLfloat u)
{
    UNIMPLEMENTED();
}

void Context::evalCoord1fv(const GLfloat *u)
{
    UNIMPLEMENTED();
}

void Context::evalCoord2d(GLdouble u, GLdouble v)
{
    UNIMPLEMENTED();
}

void Context::evalCoord2dv(const GLdouble *u)
{
    UNIMPLEMENTED();
}

void Context::evalCoord2f(GLfloat u, GLfloat v)
{
    UNIMPLEMENTED();
}

void Context::evalCoord2fv(const GLfloat *u)
{
    UNIMPLEMENTED();
}

void Context::evalMesh1(GLenum mode, GLint i1, GLint i2)
{
    UNIMPLEMENTED();
}

void Context::evalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
    UNIMPLEMENTED();
}

void Context::evalPoint1(GLint i)
{
    UNIMPLEMENTED();
}

void Context::evalPoint2(GLint i, GLint j)
{
    UNIMPLEMENTED();
}

void Context::feedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
    UNIMPLEMENTED();
}

void Context::fogi(GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::fogiv(GLenum pname, const GLint *params)
{
    UNIMPLEMENTED();
}

void Context::frustum(GLdouble left,
                      GLdouble right,
                      GLdouble bottom,
                      GLdouble top,
                      GLdouble zNear,
                      GLdouble zFar)
{
    UNIMPLEMENTED();
}

GLuint Context::genLists(GLsizei range)
{
    UNIMPLEMENTED();
    return 0;
}

void Context::getClipPlane(GLenum plane, GLdouble *equation)
{
    UNIMPLEMENTED();
}

void Context::getDoublev(GLenum pname, GLdouble *data)
{
    UNIMPLEMENTED();
}

void Context::getLightiv(GLenum light, GLenum pname, GLint *params)
{
    UNIMPLEMENTED();
}

void Context::getMapdv(GLenum target, GLenum query, GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::getMapfv(GLenum target, GLenum query, GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::getMapiv(GLenum target, GLenum query, GLint *v)
{
    UNIMPLEMENTED();
}

void Context::getMaterialiv(GLenum face, GLenum pname, GLint *params)
{
    UNIMPLEMENTED();
}

void Context::getPixelMapfv(GLenum map, GLfloat *values)
{
    UNIMPLEMENTED();
}

void Context::getPixelMapuiv(GLenum map, GLuint *values)
{
    UNIMPLEMENTED();
}

void Context::getPixelMapusv(GLenum map, GLushort *values)
{
    UNIMPLEMENTED();
}

void Context::getPolygonStipple(GLubyte *mask)
{
    UNIMPLEMENTED();
}

void Context::getTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
    UNIMPLEMENTED();
}

void Context::getTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
    UNIMPLEMENTED();
}

void Context::indexMask(GLuint mask)
{
    UNIMPLEMENTED();
}

void Context::indexd(GLdouble c)
{
    UNIMPLEMENTED();
}

void Context::indexdv(const GLdouble *c)
{
    UNIMPLEMENTED();
}

void Context::indexf(GLfloat c)
{
    UNIMPLEMENTED();
}

void Context::indexfv(const GLfloat *c)
{
    UNIMPLEMENTED();
}

void Context::indexi(GLint c)
{
    UNIMPLEMENTED();
}

void Context::indexiv(const GLint *c)
{
    UNIMPLEMENTED();
}

void Context::indexs(GLshort c)
{
    UNIMPLEMENTED();
}

void Context::indexsv(const GLshort *c)
{
    UNIMPLEMENTED();
}

void Context::initNames()
{
    UNIMPLEMENTED();
}

GLboolean Context::isList(GLuint list)
{
    UNIMPLEMENTED();
    return false;
}

void Context::lightModeli(GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::lightModeliv(GLenum pname, const GLint *params)
{
    UNIMPLEMENTED();
}

void Context::lighti(GLenum light, GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::lightiv(GLenum light, GLenum pname, const GLint *params)
{
    UNIMPLEMENTED();
}

void Context::lineStipple(GLint factor, GLushort pattern)
{
    UNIMPLEMENTED();
}

void Context::listBase(GLuint base)
{
    UNIMPLEMENTED();
}

void Context::loadMatrixd(const GLdouble *m)
{
    UNIMPLEMENTED();
}

void Context::loadName(GLuint name)
{
    UNIMPLEMENTED();
}

void Context::map1d(GLenum target,
                    GLdouble u1,
                    GLdouble u2,
                    GLint stride,
                    GLint order,
                    const GLdouble *points)
{
    UNIMPLEMENTED();
}

void Context::map1f(GLenum target,
                    GLfloat u1,
                    GLfloat u2,
                    GLint stride,
                    GLint order,
                    const GLfloat *points)
{
    UNIMPLEMENTED();
}

void Context::map2d(GLenum target,
                    GLdouble u1,
                    GLdouble u2,
                    GLint ustride,
                    GLint uorder,
                    GLdouble v1,
                    GLdouble v2,
                    GLint vstride,
                    GLint vorder,
                    const GLdouble *points)
{
    UNIMPLEMENTED();
}

void Context::map2f(GLenum target,
                    GLfloat u1,
                    GLfloat u2,
                    GLint ustride,
                    GLint uorder,
                    GLfloat v1,
                    GLfloat v2,
                    GLint vstride,
                    GLint vorder,
                    const GLfloat *points)
{
    UNIMPLEMENTED();
}

void Context::mapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
    UNIMPLEMENTED();
}

void Context::mapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
    UNIMPLEMENTED();
}

void Context::mapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
    UNIMPLEMENTED();
}

void Context::mapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
    UNIMPLEMENTED();
}

void Context::materiali(GLenum face, GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::materialiv(GLenum face, GLenum pname, const GLint *params)
{
    UNIMPLEMENTED();
}

void Context::multMatrixd(const GLdouble *m)
{
    UNIMPLEMENTED();
}

void Context::newList(GLuint list, GLenum mode)
{
    UNIMPLEMENTED();
}

void Context::normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
    UNIMPLEMENTED();
}

void Context::normal3bv(const GLbyte *v)
{
    UNIMPLEMENTED();
}

void Context::normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
    UNIMPLEMENTED();
}

void Context::normal3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::normal3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::normal3i(GLint nx, GLint ny, GLint nz)
{
    UNIMPLEMENTED();
}

void Context::normal3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::normal3s(GLshort nx, GLshort ny, GLshort nz)
{
    UNIMPLEMENTED();
}

void Context::normal3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::ortho(GLdouble left,
                    GLdouble right,
                    GLdouble bottom,
                    GLdouble top,
                    GLdouble zNear,
                    GLdouble zFar)
{
    UNIMPLEMENTED();
}

void Context::passThrough(GLfloat token)
{
    UNIMPLEMENTED();
}

void Context::pixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
    UNIMPLEMENTED();
}

void Context::pixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
    UNIMPLEMENTED();
}

void Context::pixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
    UNIMPLEMENTED();
}

void Context::pixelStoref(GLenum pname, GLfloat param)
{
    UNIMPLEMENTED();
}

void Context::pixelTransferf(GLenum pname, GLfloat param)
{
    UNIMPLEMENTED();
}

void Context::pixelTransferi(GLenum pname, GLint param)
{
    UNIMPLEMENTED();
}

void Context::pixelZoom(GLfloat xfactor, GLfloat yfactor)
{
    UNIMPLEMENTED();
}

void Context::polygonMode(GLenum face, GLenum mode)
{
    UNIMPLEMENTED();
}

void Context::polygonStipple(const GLubyte *mask)
{
    UNIMPLEMENTED();
}

void Context::popAttrib()
{
    UNIMPLEMENTED();
}

void Context::popName()
{
    UNIMPLEMENTED();
}

void Context::pushAttrib(GLbitfield mask)
{
    UNIMPLEMENTED();
}

void Context::pushName(GLuint name)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2d(GLdouble x, GLdouble y)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2f(GLfloat x, GLfloat y)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2i(GLint x, GLint y)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2s(GLshort x, GLshort y)
{
    UNIMPLEMENTED();
}

void Context::rasterPos2sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3i(GLint x, GLint y, GLint z)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3s(GLshort x, GLshort y, GLshort z)
{
    UNIMPLEMENTED();
}

void Context::rasterPos3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    UNIMPLEMENTED();
}

void Context::rasterPos4sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
    UNIMPLEMENTED();
}

void Context::rectdv(const GLdouble *v1, const GLdouble *v2)
{
    UNIMPLEMENTED();
}

void Context::rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
    UNIMPLEMENTED();
}

void Context::rectfv(const GLfloat *v1, const GLfloat *v2)
{
    UNIMPLEMENTED();
}

void Context::recti(GLint x1, GLint y1, GLint x2, GLint y2)
{
    UNIMPLEMENTED();
}

void Context::rectiv(const GLint *v1, const GLint *v2)
{
    UNIMPLEMENTED();
}

void Context::rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
    UNIMPLEMENTED();
}

void Context::rectsv(const GLshort *v1, const GLshort *v2)
{
    UNIMPLEMENTED();
}

GLint Context::renderMode(GLenum mode)
{
    UNIMPLEMENTED();
    return 0;
}

void Context::rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::scaled(GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::selectBuffer(GLsizei size, GLuint *buffer)
{
    UNIMPLEMENTED();
}

void Context::texCoord1d(GLdouble s)
{
    UNIMPLEMENTED();
}

void Context::texCoord1dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord1f(GLfloat s)
{
    UNIMPLEMENTED();
}

void Context::texCoord1fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord1i(GLint s)
{
    UNIMPLEMENTED();
}

void Context::texCoord1iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord1s(GLshort s)
{
    UNIMPLEMENTED();
}

void Context::texCoord1sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord2d(GLdouble s, GLdouble t)
{
    UNIMPLEMENTED();
}

void Context::texCoord2dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord2f(GLfloat s, GLfloat t)
{
    UNIMPLEMENTED();
}

void Context::texCoord2fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord2i(GLint s, GLint t)
{
    UNIMPLEMENTED();
}

void Context::texCoord2iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord2s(GLshort s, GLshort t)
{
    UNIMPLEMENTED();
}

void Context::texCoord2sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
    UNIMPLEMENTED();
}

void Context::texCoord3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
    UNIMPLEMENTED();
}

void Context::texCoord3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord3i(GLint s, GLint t, GLint r)
{
    UNIMPLEMENTED();
}

void Context::texCoord3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord3s(GLshort s, GLshort t, GLshort r)
{
    UNIMPLEMENTED();
}

void Context::texCoord3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    UNIMPLEMENTED();
}

void Context::texCoord4dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
    UNIMPLEMENTED();
}

void Context::texCoord4fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord4i(GLint s, GLint t, GLint r, GLint q)
{
    UNIMPLEMENTED();
}

void Context::texCoord4iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::texCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
    UNIMPLEMENTED();
}

void Context::texCoord4sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::texGend(GLenum coord, GLenum pname, GLdouble param)
{
    UNIMPLEMENTED();
}

void Context::texGendv(GLenum coord, GLenum pname, const GLdouble *params)
{
    UNIMPLEMENTED();
}

void Context::texImage1D(GLenum target,
                         GLint level,
                         GLint internalformat,
                         GLsizei width,
                         GLint border,
                         GLenum format,
                         GLenum type,
                         const void *pixels)
{
    UNIMPLEMENTED();
}

void Context::translated(GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::vertex2d(GLdouble x, GLdouble y)
{
    UNIMPLEMENTED();
}

void Context::vertex2dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertex2f(GLfloat x, GLfloat y)
{
    UNIMPLEMENTED();
}

void Context::vertex2fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::vertex2i(GLint x, GLint y)
{
    UNIMPLEMENTED();
}

void Context::vertex2iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertex2s(GLshort x, GLshort y)
{
    UNIMPLEMENTED();
}

void Context::vertex2sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertex3d(GLdouble x, GLdouble y, GLdouble z)
{
    UNIMPLEMENTED();
}

void Context::vertex3dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertex3f(GLfloat x, GLfloat y, GLfloat z)
{
    UNIMPLEMENTED();
}

void Context::vertex3fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::vertex3i(GLint x, GLint y, GLint z)
{
    UNIMPLEMENTED();
}

void Context::vertex3iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertex3s(GLshort x, GLshort y, GLshort z)
{
    UNIMPLEMENTED();
}

void Context::vertex3sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

void Context::vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    UNIMPLEMENTED();
}

void Context::vertex4dv(const GLdouble *v)
{
    UNIMPLEMENTED();
}

void Context::vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    UNIMPLEMENTED();
}

void Context::vertex4fv(const GLfloat *v)
{
    UNIMPLEMENTED();
}

void Context::vertex4i(GLint x, GLint y, GLint z, GLint w)
{
    UNIMPLEMENTED();
}

void Context::vertex4iv(const GLint *v)
{
    UNIMPLEMENTED();
}

void Context::vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    UNIMPLEMENTED();
}

void Context::vertex4sv(const GLshort *v)
{
    UNIMPLEMENTED();
}

GLboolean Context::areTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
{
    UNIMPLEMENTED();
    return false;
}

void Context::arrayElement(GLint i)
{
    UNIMPLEMENTED();
}

void Context::copyTexImage1D(GLenum target,
                             GLint level,
                             GLenum internalformat,
                             GLint x,
                             GLint y,
                             GLsizei width,
                             GLint border)
{
    UNIMPLEMENTED();
}

void Context::copyTexSubImage1D(GLenum target,
                                GLint level,
                                GLint xoffset,
                                GLint x,
                                GLint y,
                                GLsizei width)
{
    UNIMPLEMENTED();
}

void Context::edgeFlagPointer(GLsizei stride, const void *pointer)
{
    UNIMPLEMENTED();
}

void Context::indexPointer(GLenum type, GLsizei stride, const void *pointer)
{
    UNIMPLEMENTED();
}

void Context::indexub(GLubyte c)
{
    UNIMPLEMENTED();
}

void Context::indexubv(const GLubyte *c)
{
    UNIMPLEMENTED();
}

void Context::interleavedArrays(GLenum format, GLsizei stride, const void *pointer)
{
    UNIMPLEMENTED();
}

void Context::popClientAttrib()
{
    UNIMPLEMENTED();
}

void Context::prioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
{
    UNIMPLEMENTED();
}

void Context::pushClientAttrib(GLbitfield mask)
{
    UNIMPLEMENTED();
}

void Context::texSubImage1D(GLenum target,
                            GLint level,
                            GLint xoffset,
                            GLsizei width,
                            GLenum format,
                            GLenum type,
                            const void *pixels)
{
    UNIMPLEMENTED();
}

}  // namespace gl
