/*
 * Module code.
 *
 * Generated by SIP 4.16.9
 *
 * Copyright (c) 2015 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt5.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPI_QOpenGLFunctions_4_1_Core.h"


/* Define the strings used by this module. */
const char sipStrings__QOpenGLFunctions_4_1_Core[] = {
    'g', 'l', 'R', 'e', 'n', 'd', 'e', 'r', 'b', 'u', 'f', 'f', 'e', 'r', 'S', 't', 'o', 'r', 'a', 'g', 'e', 'M', 'u', 'l', 't', 'i', 's', 'a', 'm', 'p', 'l', 'e', 0,
    'P', 'y', 'Q', 't', '5', '.', '_', 'Q', 'O', 'p', 'e', 'n', 'G', 'L', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 's', '_', '4', '_', '1', '_', 'C', 'o', 'r', 'e', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 'S', 't', 'r', 'e', 'a', 'm', 0,
    'g', 'l', 'D', 'i', 's', 'a', 'b', 'l', 'e', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    'g', 'l', 'V', 'a', 'l', 'i', 'd', 'a', 't', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'P', 'i', 'p', 'e', 'l', 'i', 'n', 'e', 0,
    'g', 'l', 'R', 'e', 's', 'u', 'm', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'R', 'e', 'n', 'd', 'e', 'r', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'L', 'a', 'y', 'e', 'r', 0,
    'g', 'l', 'E', 'n', 'a', 'b', 'l', 'e', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '3', 'D', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'O', 'p', 'e', 'n', 'G', 'L', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 's', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'E', 'q', 'u', 'a', 't', 'i', 'o', 'n', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 'i', 0,
    'g', 'l', 'P', 'a', 'u', 's', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'B', 'e', 'g', 'i', 'n', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'B', 'e', 'g', 'i', 'n', 'C', 'o', 'n', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'R', 'e', 'n', 'd', 'e', 'r', 0,
    'g', 'l', 'C', 'h', 'e', 'c', 'k', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'S', 't', 'a', 't', 'u', 's', 0,
    'g', 'l', 'G', 'e', 't', 'T', 'e', 'x', 'L', 'e', 'v', 'e', 'l', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'T', 'e', 'x', 'L', 'e', 'v', 'e', 'l', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 'C', 'o', 'm', 'p', 'i', 'l', 'e', 'r', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '2', 'D', 'M', 'u', 'l', 't', 'i', 's', 'a', 'm', 'p', 'l', 'e', 0,
    'g', 'l', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '3', 'D', 'M', 'u', 'l', 't', 'i', 's', 'a', 'm', 'p', 'l', 'e', 0,
    'g', 'l', 'P', 'r', 'i', 'm', 'i', 't', 'i', 'v', 'e', 'R', 'e', 's', 't', 'a', 'r', 't', 'I', 'n', 'd', 'e', 'x', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'E', 'q', 'u', 'a', 't', 'i', 'o', 'n', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 0,
    'g', 'l', 'E', 'n', 'd', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'E', 'n', 'd', 'C', 'o', 'n', 'd', 'i', 't', 'i', 'o', 'n', 'a', 'l', 'R', 'e', 'n', 'd', 'e', 'r', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'T', 'e', 'x', 't', 'u', 'r', 'e', '1', 'D', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'T', 'e', 'x', 't', 'u', 'r', 'e', '2', 'D', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'T', 'e', 'x', 't', 'u', 'r', 'e', '3', 'D', 0,
    'g', 'l', 'G', 'e', 't', 'B', 'u', 'f', 'f', 'e', 'r', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '3', 'D', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'r', 'e', 's', 's', 'e', 'd', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'g', 'l', 'A', 'c', 't', 'i', 'v', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'P', 'i', 'p', 'e', 'l', 'i', 'n', 'e', 0,
    'g', 'l', 'I', 's', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'F', 'e', 'e', 'd', 'b', 'a', 'c', 'k', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'D', 'i', 'v', 'i', 's', 'o', 'r', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'A', 'r', 'r', 'a', 'y', 's', 'I', 'n', 's', 't', 'a', 'n', 'c', 'e', 'd', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'B', 'l', 'o', 'c', 'k', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 0,
    'g', 'l', 'R', 'e', 'n', 'd', 'e', 'r', 'b', 'u', 'f', 'f', 'e', 'r', 'S', 't', 'o', 'r', 'a', 'g', 'e', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'F', 'u', 'n', 'c', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'M', 'a', 's', 'k', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'P', 'o', 'i', 'n', 't', 'e', 'r', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'F', 'u', 'n', 'c', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 'i', 0,
    'g', 'l', 'S', 'e', 'c', 'o', 'n', 'd', 'a', 'r', 'y', 'C', 'o', 'l', 'o', 'r', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'A', 't', 't', 'r', 'i', 'b', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'g', 'l', 'G', 'e', 't', 'A', 't', 't', 'a', 'c', 'h', 'e', 'd', 'S', 'h', 'a', 'd', 'e', 'r', 's', 0,
    'g', 'l', 'G', 'e', 't', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 0,
    'g', 'l', 'I', 's', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'P', 'i', 'p', 'e', 'l', 'i', 'n', 'e', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'u', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'u', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'u', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'u', 'i', 0,
    'g', 'l', 'D', 'e', 'p', 't', 'h', 'R', 'a', 'n', 'g', 'e', 'I', 'n', 'd', 'e', 'x', 'e', 'd', 0,
    'g', 'l', 'B', 'e', 'g', 'i', 'n', 'Q', 'u', 'e', 'r', 'y', 'I', 'n', 'd', 'e', 'x', 'e', 'd', 0,
    'g', 'l', 'S', 'a', 'm', 'p', 'l', 'e', 'r', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 0,
    'g', 'l', 'S', 'a', 'm', 'p', 'l', 'e', 'r', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 0,
    'g', 'l', 'M', 'u', 'l', 't', 'i', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '1', 'u', 'i', 0,
    'g', 'l', 'M', 'u', 'l', 't', 'i', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '2', 'u', 'i', 0,
    'g', 'l', 'M', 'u', 'l', 't', 'i', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'M', 'u', 'l', 't', 'i', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '4', 'u', 'i', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'O', 'p', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 0,
    'g', 'l', 'G', 'e', 't', 'A', 't', 't', 'r', 'i', 'b', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'g', 'l', 'G', 'e', 't', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'I', 'n', 'f', 'o', 'L', 'o', 'g', 0,
    'g', 'l', 'G', 'e', 't', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'd', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'f', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'i', 'v', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'F', 'u', 'n', 'c', 'S', 'e', 'p', 'a', 'r', 'a', 't', 'e', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'R', 'a', 'n', 'g', 'e', 'E', 'l', 'e', 'm', 'e', 'n', 't', 's', 0,
    'g', 'l', 'C', 'o', 'p', 'y', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '3', 'D', 0,
    'g', 'l', 'C', 'o', 'p', 'y', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'g', 'l', 'C', 'o', 'p', 'y', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'G', 'e', 't', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'U', 's', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'S', 't', 'a', 'g', 'e', 's', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'f', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'd', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'f', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'd', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'f', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'd', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'i', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'f', 0,
    'g', 'l', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'd', 0,
    'g', 'l', 'V', 'i', 'e', 'w', 'p', 'o', 'r', 't', 'I', 'n', 'd', 'e', 'x', 'e', 'd', 'f', 0,
    'g', 'l', 'M', 'i', 'n', 'S', 'a', 'm', 'p', 'l', 'e', 'S', 'h', 'a', 'd', 'i', 'n', 'g', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'P', '1', 'u', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'P', '2', 'u', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'P', '4', 'u', 'i', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'R', 'e', 'n', 'd', 'e', 'r', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'G', 'e', 't', 'A', 'c', 't', 'i', 'v', 'e', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 0,
    'g', 'l', 'G', 'e', 't', 'S', 'h', 'a', 'd', 'e', 'r', 'I', 'n', 'f', 'o', 'L', 'o', 'g', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'M', 'a', 't', 'r', 'i', 'x', '2', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'M', 'a', 't', 'r', 'i', 'x', '3', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'M', 'a', 't', 'r', 'i', 'x', '4', 'f', 'v', 0,
    'g', 'l', 'P', 'o', 'i', 'n', 't', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 'v', 0,
    'g', 'l', 'P', 'o', 'i', 'n', 't', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'L', '1', 'd', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'L', '2', 'd', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'L', '3', 'd', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'A', 't', 't', 'r', 'i', 'b', 'L', '4', 'd', 0,
    'g', 'l', 'P', 'a', 't', 'c', 'h', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 0,
    'g', 'l', 'E', 'n', 'd', 'Q', 'u', 'e', 'r', 'y', 'I', 'n', 'd', 'e', 'x', 'e', 'd', 0,
    'g', 'l', 'P', 'r', 'o', 'v', 'o', 'k', 'i', 'n', 'g', 'V', 'e', 'r', 't', 'e', 'x', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'B', 'l', 'i', 't', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'V', 'e', 'r', 't', 'e', 'x', 'A', 'r', 'r', 'a', 'y', 0,
    'g', 'l', 'G', 'e', 't', 'A', 'c', 't', 'i', 'v', 'e', 'A', 't', 't', 'r', 'i', 'b', 0,
    'g', 'l', 'G', 'e', 't', 'S', 'h', 'a', 'd', 'e', 'r', 'S', 'o', 'u', 'r', 'c', 'e', 0,
    'g', 'l', 'V', 'a', 'l', 'i', 'd', 'a', 't', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'P', 'o', 'i', 'n', 't', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 0,
    'g', 'l', 'P', 'o', 'i', 'n', 't', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 0,
    'g', 'l', 'S', 'c', 'i', 's', 's', 'o', 'r', 'I', 'n', 'd', 'e', 'x', 'e', 'd', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'E', 'q', 'u', 'a', 't', 'i', 'o', 'n', 'i', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'B', 'u', 'f', 'f', 'e', 'r', 'B', 'a', 's', 'e', 0,
    'g', 'l', 'I', 's', 'R', 'e', 'n', 'd', 'e', 'r', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'G', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'M', 'i', 'p', 'm', 'a', 'p', 0,
    'g', 'l', 'S', 'a', 'm', 'p', 'l', 'e', 'C', 'o', 'v', 'e', 'r', 'a', 'g', 'e', 0,
    'g', 'l', 'C', 'o', 'p', 'y', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'g', 'l', 'C', 'o', 'p', 'y', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'D', 'e', 'l', 'e', 't', 'e', 'T', 'e', 'x', 't', 'u', 'r', 'e', 's', 0,
    'g', 'l', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 'v', 0,
    'g', 'l', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 'B', 'u', 'f', 'f', 'e', 'r', 'f', 'i', 0,
    'g', 'l', 'I', 's', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'I', 's', 'V', 'e', 'r', 't', 'e', 'x', 'A', 'r', 'r', 'a', 'y', 0,
    'g', 'l', 'C', 'o', 'm', 'p', 'i', 'l', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'C', 'r', 'e', 'a', 't', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'D', 'e', 'l', 'e', 't', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'D', 'e', 'l', 'e', 't', 'e', 'Q', 'u', 'e', 'r', 'i', 'e', 's', 0,
    'g', 'l', 'D', 'e', 'l', 'e', 't', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'g', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'u', 'b', 'D', 'a', 't', 'a', 0,
    'g', 'l', 'A', 'c', 't', 'i', 'v', 'e', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'E', 'q', 'u', 'a', 't', 'i', 'o', 'n', 0,
    'g', 'l', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '3', 'D', 0,
    'g', 'l', 'P', 'o', 'l', 'y', 'g', 'o', 'n', 'O', 'f', 'f', 's', 'e', 't', 0,
    'g', 'l', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'g', 'l', 'T', 'e', 'x', 'S', 'u', 'b', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'f', 0,
    'g', 'l', 'T', 'e', 'x', 'P', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', 'i', 0,
    'a', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 'M', 'o', 'd', 'e', 0,
    'g', 'l', 'Q', 'u', 'e', 'r', 'y', 'C', 'o', 'u', 'n', 't', 'e', 'r', 0,
    'g', 'l', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '1', 'u', 'i', 0,
    'g', 'l', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '2', 'u', 'i', 0,
    'g', 'l', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'T', 'e', 'x', 'C', 'o', 'o', 'r', 'd', 'P', '4', 'u', 'i', 0,
    'g', 'l', 'A', 't', 't', 'a', 'c', 'h', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'C', 'r', 'e', 'a', 't', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'D', 'e', 'l', 'e', 't', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'D', 'e', 't', 'a', 'c', 'h', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'G', 'e', 't', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'v', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'E', 'l', 'e', 'm', 'e', 'n', 't', 's', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 'S', 't', 'e', 'n', 'c', 'i', 'l', 0,
    'g', 'l', 'D', 'e', 'p', 't', 'h', 'R', 'a', 'n', 'g', 'e', 'f', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 'D', 'e', 'p', 't', 'h', 'f', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'S', 'a', 'm', 'p', 'l', 'e', 'r', 0,
    'g', 'l', 'S', 'a', 'm', 'p', 'l', 'e', 'M', 'a', 's', 'k', 'i', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'g', 'l', 'G', 'e', 't', 'S', 'h', 'a', 'd', 'e', 'r', 'i', 'v', 0,
    'g', 'l', 'L', 'i', 'n', 'k', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'U', 'n', 'm', 'a', 'p', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'g', 'l', 'G', 'e', 'n', 'T', 'e', 'x', 't', 'u', 'r', 'e', 's', 0,
    'g', 'l', 'P', 'o', 'l', 'y', 'g', 'o', 'n', 'M', 'o', 'd', 'e', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'M', 'a', 's', 'k', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'F', 'u', 'n', 'c', 0,
    'g', 'l', 'P', 'i', 'x', 'e', 'l', 'S', 't', 'o', 'r', 'e', 'f', 0,
    'g', 'l', 'P', 'i', 'x', 'e', 'l', 'S', 't', 'o', 'r', 'e', 'i', 0,
    'g', 'l', 'G', 'e', 't', 'B', 'o', 'o', 'l', 'e', 'a', 'n', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'I', 'n', 't', 'e', 'g', 'e', 'r', 'v', 0,
    't', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'M', 'o', 'd', 'e', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'F', 'u', 'n', 'c', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'P', '2', 'u', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'V', 'e', 'r', 't', 'e', 'x', 'P', '4', 'u', 'i', 0,
    'g', 'l', 'N', 'o', 'r', 'm', 'a', 'l', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'C', 'o', 'l', 'o', 'r', 'M', 'a', 's', 'k', 'i', 0,
    'g', 'l', 'I', 's', 'E', 'n', 'a', 'b', 'l', 'e', 'd', 'i', 0,
    'g', 'l', 'C', 'l', 'a', 'm', 'p', 'C', 'o', 'l', 'o', 'r', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'u', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'u', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'u', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'u', 'i', 0,
    'g', 'l', 'U', 's', 'e', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'f', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'i', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'i', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'i', 'v', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'i', 'v', 0,
    'g', 'l', 'G', 'e', 'n', 'Q', 'u', 'e', 'r', 'i', 'e', 's', 0,
    'g', 'l', 'B', 'e', 'g', 'i', 'n', 'Q', 'u', 'e', 'r', 'y', 0,
    'g', 'l', 'G', 'e', 't', 'Q', 'u', 'e', 'r', 'y', 'i', 'v', 0,
    'g', 'l', 'B', 'i', 'n', 'd', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'G', 'e', 'n', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'g', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 'D', 'a', 't', 'a', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'C', 'o', 'l', 'o', 'r', 0,
    'g', 'l', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '3', 'D', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'A', 'r', 'r', 'a', 'y', 's', 0,
    'g', 'l', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '1', 'D', 0,
    'g', 'l', 'T', 'e', 'x', 'I', 'm', 'a', 'g', 'e', '2', 'D', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 'C', 'o', 'l', 'o', 'r', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 'D', 'e', 'p', 't', 'h', 0,
    'g', 'l', 'R', 'e', 'a', 'd', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'G', 'e', 't', 'D', 'o', 'u', 'b', 'l', 'e', 'v', 0,
    'g', 'l', 'D', 'e', 'p', 't', 'h', 'R', 'a', 'n', 'g', 'e', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'R', 'e', 'c', 't', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'd', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'd', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'd', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'd', 0,
    'g', 'l', 'I', 's', 'S', 'a', 'm', 'p', 'l', 'e', 'r', 0,
    'g', 'l', 'C', 'o', 'l', 'o', 'r', 'P', '3', 'u', 'i', 0,
    'g', 'l', 'C', 'o', 'l', 'o', 'r', 'P', '4', 'u', 'i', 0,
    'g', 'l', 'T', 'e', 'x', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'I', 's', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'f', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'f', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'f', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'f', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '1', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '2', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '3', 'i', 0,
    'g', 'l', 'U', 'n', 'i', 'f', 'o', 'r', 'm', '4', 'i', 0,
    'g', 'l', 'I', 's', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'g', 'l', 'F', 'r', 'o', 'n', 't', 'F', 'a', 'c', 'e', 0,
    'g', 'l', 'L', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'g', 'l', 'P', 'o', 'i', 'n', 't', 'S', 'i', 'z', 'e', 0,
    'g', 'l', 'C', 'o', 'l', 'o', 'r', 'M', 'a', 's', 'k', 0,
    'g', 'l', 'D', 'e', 'p', 't', 'h', 'M', 'a', 's', 'k', 0,
    'g', 'l', 'B', 'l', 'e', 'n', 'd', 'F', 'u', 'n', 'c', 0,
    'g', 'l', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'O', 'p', 0,
    'g', 'l', 'D', 'e', 'p', 't', 'h', 'F', 'u', 'n', 'c', 0,
    'g', 'l', 'G', 'e', 't', 'F', 'l', 'o', 'a', 't', 'v', 0,
    'g', 'l', 'G', 'e', 't', 'S', 't', 'r', 'i', 'n', 'g', 0,
    'g', 'l', 'I', 's', 'E', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'm', 'a', 't', 'c', 'h', 'P', 'o', 'l', 'i', 'c', 'y', 0,
    'g', 'l', 'D', 'i', 's', 'a', 'b', 'l', 'e', 'i', 0,
    'g', 'l', 'I', 's', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'g', 'l', 'E', 'n', 'd', 'Q', 'u', 'e', 'r', 'y', 0,
    'g', 'l', 'I', 's', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'l', 'I', 'n', 'd', 'e', 'x', 'u', 'b', 'v', 0,
    'g', 'l', 'C', 'u', 'l', 'l', 'F', 'a', 'c', 'e', 0,
    'g', 'l', 'G', 'e', 't', 'E', 'r', 'r', 'o', 'r', 0,
    'g', 'l', 'V', 'i', 'e', 'w', 'p', 'o', 'r', 't', 0,
    'g', 'e', 'n', 'M', 'i', 'p', 'M', 'a', 'p', 's', 0,
    'g', 'l', 'E', 'n', 'a', 'b', 'l', 'e', 'i', 0,
    'g', 'l', 'I', 's', 'Q', 'u', 'e', 'r', 'y', 0,
    'g', 'l', 'I', 'n', 'd', 'e', 'x', 'u', 'b', 0,
    'g', 'l', 'S', 'c', 'i', 's', 's', 'o', 'r', 0,
    'g', 'l', 'D', 'i', 's', 'a', 'b', 'l', 'e', 0,
    'g', 'l', 'L', 'o', 'g', 'i', 'c', 'O', 'p', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'a', 'l', 'i', 'g', 'n', 'm', 'e', 'n', 't', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'g', 'l', 'E', 'n', 'a', 'b', 'l', 'e', 0,
    'g', 'l', 'F', 'i', 'n', 'i', 's', 'h', 0,
    'f', 'i', 'l', 'l', 'R', 'u', 'l', 'e', 0,
    't', 'a', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    't', 'a', 'b', 'S', 't', 'o', 'p', 's', 0,
    'n', 'a', 'm', 'e', 'T', 'y', 'p', 'e', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'g', 'l', 'C', 'l', 'e', 'a', 'r', 0,
    'g', 'l', 'F', 'l', 'u', 's', 'h', 0,
    'e', 'x', 'p', 'o', 's', 'e', 'd', 0,
    'b', 'u', 'f', 'f', 'e', 'r', 's', 0,
    's', 'o', 'u', 'r', 'c', 'e', 's', 0,
    'q', 'u', 'a', 'l', 'i', 't', 'y', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'g', 'l', 'H', 'i', 'n', 't', 0,
    's', 't', 'r', 'i', 'd', 'e', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'f', 'i', 'l', 't', 'e', 'r', 0,
    'o', 'p', 't', 'i', 'o', 'n', 0,
    'l', 'o', 'c', 'a', 'l', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    't', 'y', 'p', 'e', 's', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 't', 'e', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'p', 'o', 's', 0,
    's', 'w', 0,
    's', 'y', 0,
    's', 'x', 0,
};
#line 1204 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
// Imports from QtGui.
qpyopengl_value_array_t qpyopengl_value_array;
qpyopengl_value_array_cached_t qpyopengl_value_array_cached;
qpyopengl_from_GLint_t qpyopengl_from_GLint;
qpyopengl_from_GLuint_t qpyopengl_from_GLuint;
qpyopengl_from_GLboolean_t qpyopengl_from_GLboolean;
qpyopengl_from_GLfloat_t qpyopengl_from_GLfloat;
qpyopengl_from_GLdouble_t qpyopengl_from_GLdouble;
#line 358 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"


/*
 * This defines each type in this module.
 */
static sipTypeDef *typesTable[] = {
    &sipTypeDef__QOpenGLFunctions_4_1_Core_QOpenGLFunctions_4_1_Core.super.ctd_base,
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt5.QtCore", 1, NULL},
    {"PyQt5.QtGui", -1, NULL},
    {NULL, -1, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI__QOpenGLFunctions_4_1_Core = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt5__QOpenGLFunctions_4_1_Core,
    0,
    -1,
    sipStrings__QOpenGLFunctions_4_1_Core,
    importsTable,
    NULL,
    1,
    typesTable,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    NULL,
    NULL,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI__QOpenGLFunctions_4_1_Core;
const sipExportedModuleDef *sipModuleAPI__QOpenGLFunctions_4_1_Core_QtCore;
const sipExportedModuleDef *sipModuleAPI__QOpenGLFunctions_4_1_Core_QtGui;

sip_qt_metaobject_func sip__QOpenGLFunctions_4_1_Core_qt_metaobject;
sip_qt_metacall_func sip__QOpenGLFunctions_4_1_Core_qt_metacall;
sip_qt_metacast_func sip__QOpenGLFunctions_4_1_Core_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit__QOpenGLFunctions_4_1_Core
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        init_QOpenGLFunctions_4_1_Core
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt5._QOpenGLFunctions_4_1_Core",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt5__QOpenGLFunctions_4_1_Core, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt5__QOpenGLFunctions_4_1_Core), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule(SIP_MODULE_NAME);
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>(SIP_MODULE_NAME));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI__QOpenGLFunctions_4_1_Core = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, SIP_MODULE_NAME "._C_API"));
#else
    sipAPI__QOpenGLFunctions_4_1_Core = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI__QOpenGLFunctions_4_1_Core == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI__QOpenGLFunctions_4_1_Core,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip__QOpenGLFunctions_4_1_Core_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip__QOpenGLFunctions_4_1_Core_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip__QOpenGLFunctions_4_1_Core_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip__QOpenGLFunctions_4_1_Core_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI__QOpenGLFunctions_4_1_Core,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    /* Get the APIs of the modules that this one is dependent on. */
    sipModuleAPI__QOpenGLFunctions_4_1_Core_QtCore = sipModuleAPI__QOpenGLFunctions_4_1_Core.em_imports[0].im_module;
    sipModuleAPI__QOpenGLFunctions_4_1_Core_QtGui = sipModuleAPI__QOpenGLFunctions_4_1_Core.em_imports[1].im_module;
#line 1215 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
// Imports from QtGui.
qpyopengl_value_array = (qpyopengl_value_array_t)sipImportSymbol("qpyopengl_value_array");
qpyopengl_value_array_cached = (qpyopengl_value_array_cached_t)sipImportSymbol("qpyopengl_value_array_cached");
qpyopengl_from_GLint = (qpyopengl_from_GLint_t)sipImportSymbol("qpyopengl_from_GLint");
qpyopengl_from_GLuint = (qpyopengl_from_GLuint_t)sipImportSymbol("qpyopengl_from_GLuint");
qpyopengl_from_GLboolean = (qpyopengl_from_GLboolean_t)sipImportSymbol("qpyopengl_from_GLboolean");
qpyopengl_from_GLfloat = (qpyopengl_from_GLfloat_t)sipImportSymbol("qpyopengl_from_GLfloat");
qpyopengl_from_GLdouble = (qpyopengl_from_GLdouble_t)sipImportSymbol("qpyopengl_from_GLdouble");
#line 546 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

    SIP_MODULE_RETURN(sipModule);
}

#line 28 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
#include <qopenglfunctions_4_1_core.h>
#line 553 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"



class sipQOpenGLFunctions_4_1_Core : public QOpenGLFunctions_4_1_Core
{
public:
    sipQOpenGLFunctions_4_1_Core();
    virtual ~sipQOpenGLFunctions_4_1_Core();

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool initializeOpenGLFunctions();

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQOpenGLFunctions_4_1_Core(const sipQOpenGLFunctions_4_1_Core &);
    sipQOpenGLFunctions_4_1_Core &operator = (const sipQOpenGLFunctions_4_1_Core &);

    char sipPyMethods[1];
};

sipQOpenGLFunctions_4_1_Core::sipQOpenGLFunctions_4_1_Core(): QOpenGLFunctions_4_1_Core(), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQOpenGLFunctions_4_1_Core::~sipQOpenGLFunctions_4_1_Core()
{
    sipCommonDtor(sipPySelf);
}

bool sipQOpenGLFunctions_4_1_Core::initializeOpenGLFunctions()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_initializeOpenGLFunctions);

    if (!sipMeth)
        return QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions();

    typedef bool (*sipVH_QtCore_7)(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return ((sipVH_QtCore_7)(sipModuleAPI__QOpenGLFunctions_4_1_Core_QtCore->em_virthandlers[7]))(sipGILState, sipModuleAPI__QOpenGLFunctions_4_1_Core_QtCore->em_virterrorhandlers[0], sipPySelf, sipMeth);
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions, "QOpenGLFunctions_4_1_Core.initializeOpenGLFunctions() -> bool");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerived((sipSimpleWrapper *)sipSelf));

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            bool sipRes;

            sipRes = (sipSelfWasArg ? sipCpp->QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions() : sipCpp->initializeOpenGLFunctions());

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_initializeOpenGLFunctions, doc_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glViewport, "QOpenGLFunctions_4_1_Core.glViewport(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glViewport(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glViewport(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLsizei a2;
        GLsizei a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glViewport(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glViewport, doc_QOpenGLFunctions_4_1_Core_glViewport);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDepthRange, "QOpenGLFunctions_4_1_Core.glDepthRange(float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRange(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRange(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLdouble a0;
        GLdouble a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bdd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glDepthRange(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDepthRange, doc_QOpenGLFunctions_4_1_Core_glDepthRange);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsEnabled, "QOpenGLFunctions_4_1_Core.glIsEnabled(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsEnabled(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsEnabled(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsEnabled(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsEnabled, doc_QOpenGLFunctions_4_1_Core_glIsEnabled);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv, "QOpenGLFunctions_4_1_Core.glGetTexLevelParameteriv(int, int, int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            int sipIsErr = 0;

#line 40 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint params[1];
            
        sipCpp->glGetTexLevelParameteriv(a0, a1, a2, params);
        
        a3 = qpyopengl_from_GLint(&sipIsErr, params, 1);
#line 748 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a3;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetTexLevelParameteriv, doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv, "QOpenGLFunctions_4_1_Core.glGetTexLevelParameterfv(int, int, int) -> float-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            int sipIsErr = 0;

#line 49 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLfloat params[1];
            
        sipCpp->glGetTexLevelParameterfv(a0, a1, a2, params);
        
        a3 = qpyopengl_from_GLfloat(&sipIsErr, params, 1);
#line 788 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a3;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetTexLevelParameterfv, doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetTexParameteriv, "QOpenGLFunctions_4_1_Core.glGetTexParameteriv(int, int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexParameteriv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexParameteriv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 58 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint params[4];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_SWIZZLE_RGBA)
        #if defined(GL_TEXTURE_SWIZZLE_RGBA)
        case GL_TEXTURE_SWIZZLE_RGBA:
        #endif
        #if defined(GL_TEXTURE_BORDER_COLOR)
        case GL_TEXTURE_BORDER_COLOR:
        #endif
            nr_params = 4;
            break;
        #endif
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetTexParameteriv(a0, a1, params);
        
        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
#line 845 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetTexParameteriv, doc_QOpenGLFunctions_4_1_Core_glGetTexParameteriv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetTexParameterfv, "QOpenGLFunctions_4_1_Core.glGetTexParameterfv(int, int) -> float-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexParameterfv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetTexParameterfv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 85 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLfloat params[4];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        #if defined(GL_TEXTURE_SWIZZLE_RGBA) || defined(GL_TEXTURE_SWIZZLE_RGBA)
        #if defined(GL_TEXTURE_SWIZZLE_RGBA)
        case GL_TEXTURE_SWIZZLE_RGBA:
        #endif
        #if defined(GL_TEXTURE_BORDER_COLOR)
        case GL_TEXTURE_BORDER_COLOR:
        #endif
            nr_params = 4;
            break;
        #endif
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetTexParameterfv(a0, a1, params);
        
        a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
#line 902 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetTexParameterfv, doc_QOpenGLFunctions_4_1_Core_glGetTexParameterfv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetString, "QOpenGLFunctions_4_1_Core.glGetString(int) -> str");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetString(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetString(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            const char*sipRes = 0;

#line 112 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        sipRes = reinterpret_cast<const char *>(sipCpp->glGetString(a0));
#line 935 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipRes == NULL)
            {
                Py_INCREF(Py_None);
                return Py_None;
            }

            return SIPBytes_FromString(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetString, doc_QOpenGLFunctions_4_1_Core_glGetString);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetIntegerv, "QOpenGLFunctions_4_1_Core.glGetIntegerv(int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetIntegerv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetIntegerv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 117 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint fixed_params[4], *params;
        GLint nr_params = 0;
        GLenum query;
        
        switch (a0)
        {
        case GL_COMPRESSED_TEXTURE_FORMATS:
            query = GL_NUM_COMPRESSED_TEXTURE_FORMATS;
            break;
        
        #if defined(GL_PROGRAM_BINARY_FORMATS)
        case GL_PROGRAM_BINARY_FORMATS:
            query = GL_NUM_PROGRAM_BINARY_FORMATS;
            break;
        #endif
        
        #if defined(GL_SHADER_BINARY_FORMATS)
        case GL_SHADER_BINARY_FORMATS:
            query = GL_NUM_SHADER_BINARY_FORMATS;
            break;
        #endif
        
        case GL_BLEND_COLOR:
        case GL_COLOR_CLEAR_VALUE:
        case GL_COLOR_WRITEMASK:
        case GL_SCISSOR_BOX:
        case GL_VIEWPORT:
            nr_params = 4;
            break;
        
        case GL_ALIASED_LINE_WIDTH_RANGE:
        case GL_ALIASED_POINT_SIZE_RANGE:
        case GL_DEPTH_RANGE:
        #if defined(GL_LINE_WIDTH_RANGE)
        case GL_LINE_WIDTH_RANGE:
        #endif
        case GL_MAX_VIEWPORT_DIMS:
        #if defined(GL_POINT_SIZE_RANGE)
        case GL_POINT_SIZE_RANGE:
        #endif
        #if defined(GL_VIEWPORT_BOUNDS_RANGE)
        case GL_VIEWPORT_BOUNDS_RANGE:
        #endif
            nr_params = 2;
            break;
            
        default:
            nr_params = 1;
        }
        
        if (nr_params == 0)
        {
            sipCpp->glGetIntegerv(query, &nr_params);
            params = new GLint[nr_params];
        }
        else
        {
            params = fixed_params;
        }
        
        sipCpp->glGetIntegerv(a0, params);
        a1 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
            
        if (params != fixed_params)
            delete[] params;
#line 1036 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetIntegerv, doc_QOpenGLFunctions_4_1_Core_glGetIntegerv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetFloatv, "QOpenGLFunctions_4_1_Core.glGetFloatv(int) -> float-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetFloatv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetFloatv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 186 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLfloat fixed_params[4], *params;
        GLint nr_params = 0;
        GLenum query;
        
        switch (a0)
        {
        case GL_COMPRESSED_TEXTURE_FORMATS:
            query = GL_NUM_COMPRESSED_TEXTURE_FORMATS;
            break;
        
        #if defined(GL_PROGRAM_BINARY_FORMATS)
        case GL_PROGRAM_BINARY_FORMATS:
            query = GL_NUM_PROGRAM_BINARY_FORMATS;
            break;
        #endif
        
        #if defined(GL_SHADER_BINARY_FORMATS)
        case GL_SHADER_BINARY_FORMATS:
            query = GL_NUM_SHADER_BINARY_FORMATS;
            break;
        #endif
        
        case GL_BLEND_COLOR:
        case GL_COLOR_CLEAR_VALUE:
        case GL_COLOR_WRITEMASK:
        case GL_SCISSOR_BOX:
        case GL_VIEWPORT:
            nr_params = 4;
            break;
        
        case GL_ALIASED_LINE_WIDTH_RANGE:
        case GL_ALIASED_POINT_SIZE_RANGE:
        case GL_DEPTH_RANGE:
        #if defined(GL_LINE_WIDTH_RANGE)
        case GL_LINE_WIDTH_RANGE:
        #endif
        case GL_MAX_VIEWPORT_DIMS:
        #if defined(GL_POINT_SIZE_RANGE)
        case GL_POINT_SIZE_RANGE:
        #endif
        #if defined(GL_VIEWPORT_BOUNDS_RANGE)
        case GL_VIEWPORT_BOUNDS_RANGE:
        #endif
            nr_params = 2;
            break;
            
        default:
            nr_params = 1;
        }
        
        if (nr_params == 0)
        {
            sipCpp->glGetIntegerv(query, &nr_params);
            params = new GLfloat[nr_params];
        }
        else
        {
            params = fixed_params;
        }
        
        sipCpp->glGetFloatv(a0, params);
        a1 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
            
        if (params != fixed_params)
            delete[] params;
#line 1134 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetFloatv, doc_QOpenGLFunctions_4_1_Core_glGetFloatv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetError, "QOpenGLFunctions_4_1_Core.glGetError() -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetError(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetError(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            GLenum sipRes;

            sipRes = sipCpp->glGetError();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetError, doc_QOpenGLFunctions_4_1_Core_glGetError);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetDoublev, "QOpenGLFunctions_4_1_Core.glGetDoublev(int) -> float-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetDoublev(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetDoublev(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 256 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLdouble fixed_params[4], *params;
        GLint nr_params = 0;
        GLenum query;
        
        switch (a0)
        {
        case GL_COMPRESSED_TEXTURE_FORMATS:
            query = GL_NUM_COMPRESSED_TEXTURE_FORMATS;
            break;
        
        #if defined(GL_PROGRAM_BINARY_FORMATS)
        case GL_PROGRAM_BINARY_FORMATS:
            query = GL_NUM_PROGRAM_BINARY_FORMATS;
            break;
        #endif
        
        #if defined(GL_SHADER_BINARY_FORMATS)
        case GL_SHADER_BINARY_FORMATS:
            query = GL_NUM_SHADER_BINARY_FORMATS;
            break;
        #endif
        
        case GL_BLEND_COLOR:
        case GL_COLOR_CLEAR_VALUE:
        case GL_COLOR_WRITEMASK:
        case GL_SCISSOR_BOX:
        case GL_VIEWPORT:
            nr_params = 4;
            break;
        
        case GL_ALIASED_LINE_WIDTH_RANGE:
        case GL_ALIASED_POINT_SIZE_RANGE:
        case GL_DEPTH_RANGE:
        #if defined(GL_LINE_WIDTH_RANGE)
        case GL_LINE_WIDTH_RANGE:
        #endif
        case GL_MAX_VIEWPORT_DIMS:
        #if defined(GL_POINT_SIZE_RANGE)
        case GL_POINT_SIZE_RANGE:
        #endif
        #if defined(GL_VIEWPORT_BOUNDS_RANGE)
        case GL_VIEWPORT_BOUNDS_RANGE:
        #endif
            nr_params = 2;
            break;
            
        default:
            nr_params = 1;
        }
        
        if (nr_params == 0)
        {
            sipCpp->glGetIntegerv(query, &nr_params);
            params = new GLdouble[nr_params];
        }
        else
        {
            params = fixed_params;
        }
        
        sipCpp->glGetDoublev(a0, params);
        a1 = qpyopengl_from_GLdouble(&sipIsErr, params, nr_params);
            
        if (params != fixed_params)
            delete[] params;
#line 1259 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetDoublev, doc_QOpenGLFunctions_4_1_Core_glGetDoublev);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetBooleanv, "QOpenGLFunctions_4_1_Core.glGetBooleanv(int) -> bool-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetBooleanv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetBooleanv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 325 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLboolean fixed_params[4], *params;
        GLint nr_params = 0;
        GLenum query;
        
        switch (a0)
        {
        case GL_COMPRESSED_TEXTURE_FORMATS:
            query = GL_NUM_COMPRESSED_TEXTURE_FORMATS;
            break;
        
        #if defined(GL_PROGRAM_BINARY_FORMATS)
        case GL_PROGRAM_BINARY_FORMATS:
            query = GL_NUM_PROGRAM_BINARY_FORMATS;
            break;
        #endif
        
        #if defined(GL_SHADER_BINARY_FORMATS)
        case GL_SHADER_BINARY_FORMATS:
            query = GL_NUM_SHADER_BINARY_FORMATS;
            break;
        #endif
        
        case GL_BLEND_COLOR:
        case GL_COLOR_CLEAR_VALUE:
        case GL_COLOR_WRITEMASK:
        case GL_SCISSOR_BOX:
        case GL_VIEWPORT:
            nr_params = 4;
            break;
        
        case GL_ALIASED_LINE_WIDTH_RANGE:
        case GL_ALIASED_POINT_SIZE_RANGE:
        case GL_DEPTH_RANGE:
        #if defined(GL_LINE_WIDTH_RANGE)
        case GL_LINE_WIDTH_RANGE:
        #endif
        case GL_MAX_VIEWPORT_DIMS:
        #if defined(GL_POINT_SIZE_RANGE)
        case GL_POINT_SIZE_RANGE:
        #endif
        #if defined(GL_VIEWPORT_BOUNDS_RANGE)
        case GL_VIEWPORT_BOUNDS_RANGE:
        #endif
            nr_params = 2;
            break;
            
        default:
            nr_params = 1;
        }
        
        if (nr_params == 0)
        {
            sipCpp->glGetIntegerv(query, &nr_params);
            params = new GLboolean[nr_params];
        }
        else
        {
            params = fixed_params;
        }
        
        sipCpp->glGetBooleanv(a0, params);
        a1 = qpyopengl_from_GLboolean(&sipIsErr, params, nr_params);
            
        if (params != fixed_params)
            delete[] params;
#line 1357 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetBooleanv, doc_QOpenGLFunctions_4_1_Core_glGetBooleanv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glReadBuffer, "QOpenGLFunctions_4_1_Core.glReadBuffer(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glReadBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glReadBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glReadBuffer(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glReadBuffer, doc_QOpenGLFunctions_4_1_Core_glReadBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPixelStorei, "QOpenGLFunctions_4_1_Core.glPixelStorei(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPixelStorei(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPixelStorei(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPixelStorei(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPixelStorei, doc_QOpenGLFunctions_4_1_Core_glPixelStorei);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPixelStoref, "QOpenGLFunctions_4_1_Core.glPixelStoref(int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPixelStoref(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPixelStoref(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLfloat a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPixelStoref(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPixelStoref, doc_QOpenGLFunctions_4_1_Core_glPixelStoref);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDepthFunc, "QOpenGLFunctions_4_1_Core.glDepthFunc(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthFunc(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthFunc(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDepthFunc(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDepthFunc, doc_QOpenGLFunctions_4_1_Core_glDepthFunc);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilOp, "QOpenGLFunctions_4_1_Core.glStencilOp(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilOp(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilOp(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glStencilOp(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilOp, doc_QOpenGLFunctions_4_1_Core_glStencilOp);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilFunc, "QOpenGLFunctions_4_1_Core.glStencilFunc(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilFunc(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilFunc(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glStencilFunc(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilFunc, doc_QOpenGLFunctions_4_1_Core_glStencilFunc);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glLogicOp, "QOpenGLFunctions_4_1_Core.glLogicOp(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glLogicOp(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glLogicOp(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glLogicOp(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glLogicOp, doc_QOpenGLFunctions_4_1_Core_glLogicOp);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendFunc, "QOpenGLFunctions_4_1_Core.glBlendFunc(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFunc(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFunc(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBlendFunc(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendFunc, doc_QOpenGLFunctions_4_1_Core_glBlendFunc);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFlush, "QOpenGLFunctions_4_1_Core.glFlush()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFlush(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFlush(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glFlush();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFlush, doc_QOpenGLFunctions_4_1_Core_glFlush);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFinish, "QOpenGLFunctions_4_1_Core.glFinish()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFinish(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFinish(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glFinish();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFinish, doc_QOpenGLFunctions_4_1_Core_glFinish);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEnable, "QOpenGLFunctions_4_1_Core.glEnable(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnable(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glEnable(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEnable, doc_QOpenGLFunctions_4_1_Core_glEnable);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDisable, "QOpenGLFunctions_4_1_Core.glDisable(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisable(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisable(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDisable(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDisable, doc_QOpenGLFunctions_4_1_Core_glDisable);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDepthMask, "QOpenGLFunctions_4_1_Core.glDepthMask(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthMask(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthMask(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLboolean a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDepthMask(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDepthMask, doc_QOpenGLFunctions_4_1_Core_glDepthMask);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glColorMask, "QOpenGLFunctions_4_1_Core.glColorMask(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorMask(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorMask(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLboolean a0;
        GLboolean a1;
        GLboolean a2;
        GLboolean a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BMMMM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glColorMask(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glColorMask, doc_QOpenGLFunctions_4_1_Core_glColorMask);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilMask, "QOpenGLFunctions_4_1_Core.glStencilMask(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilMask(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilMask(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glStencilMask(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilMask, doc_QOpenGLFunctions_4_1_Core_glStencilMask);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClearDepth, "QOpenGLFunctions_4_1_Core.glClearDepth(float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearDepth(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearDepth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLdouble a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glClearDepth(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClearDepth, doc_QOpenGLFunctions_4_1_Core_glClearDepth);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClearStencil, "QOpenGLFunctions_4_1_Core.glClearStencil(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearStencil(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearStencil(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glClearStencil(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClearStencil, doc_QOpenGLFunctions_4_1_Core_glClearStencil);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClearColor, "QOpenGLFunctions_4_1_Core.glClearColor(float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearColor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        GLfloat a1;
        GLfloat a2;
        GLfloat a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bffff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glClearColor(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClearColor, doc_QOpenGLFunctions_4_1_Core_glClearColor);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClear, "QOpenGLFunctions_4_1_Core.glClear(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClear(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClear(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLbitfield a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glClear(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClear, doc_QOpenGLFunctions_4_1_Core_glClear);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawBuffer, "QOpenGLFunctions_4_1_Core.glDrawBuffer(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDrawBuffer(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawBuffer, doc_QOpenGLFunctions_4_1_Core_glDrawBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexImage2D, "QOpenGLFunctions_4_1_Core.glTexImage2D(int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLsizei a4;
        GLint a5;
        GLenum a6;
        GLenum a7;
        PyObject * a8;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
        {
            sipErrorState sipError = sipErrorNone;

#line 414 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
#line 1952 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexImage2D, doc_QOpenGLFunctions_4_1_Core_glTexImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexImage1D, "QOpenGLFunctions_4_1_Core.glTexImage1D(int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLint a4;
        GLenum a5;
        GLenum a6;
        PyObject * a7;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
        {
            sipErrorState sipError = sipErrorNone;

#line 422 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a7, a6, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexImage1D(a0, a1, a2, a3, a4, a5, a6, array);
#line 2001 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexImage1D, doc_QOpenGLFunctions_4_1_Core_glTexImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexParameteriv, "QOpenGLFunctions_4_1_Core.glTexParameteriv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameteriv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameteriv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 430 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexParameteriv(a0, a1, reinterpret_cast<const GLint *>(array));
#line 2045 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexParameteriv, doc_QOpenGLFunctions_4_1_Core_glTexParameteriv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexParameteri, "QOpenGLFunctions_4_1_Core.glTexParameteri(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameteri(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameteri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glTexParameteri(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexParameteri, doc_QOpenGLFunctions_4_1_Core_glTexParameteri);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexParameterfv, "QOpenGLFunctions_4_1_Core.glTexParameterfv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameterfv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameterfv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 439 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexParameterfv(a0, a1, reinterpret_cast<const GLfloat *>(array));
#line 2118 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexParameterfv, doc_QOpenGLFunctions_4_1_Core_glTexParameterfv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexParameterf, "QOpenGLFunctions_4_1_Core.glTexParameterf(int, int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameterf(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexParameterf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLfloat a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glTexParameterf(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexParameterf, doc_QOpenGLFunctions_4_1_Core_glTexParameterf);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glScissor, "QOpenGLFunctions_4_1_Core.glScissor(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glScissor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glScissor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLsizei a2;
        GLsizei a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glScissor(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glScissor, doc_QOpenGLFunctions_4_1_Core_glScissor);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPolygonMode, "QOpenGLFunctions_4_1_Core.glPolygonMode(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPolygonMode(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPolygonMode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPolygonMode(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPolygonMode, doc_QOpenGLFunctions_4_1_Core_glPolygonMode);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPointSize, "QOpenGLFunctions_4_1_Core.glPointSize(float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointSize(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glPointSize(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPointSize, doc_QOpenGLFunctions_4_1_Core_glPointSize);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glLineWidth, "QOpenGLFunctions_4_1_Core.glLineWidth(float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glLineWidth(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glLineWidth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glLineWidth(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glLineWidth, doc_QOpenGLFunctions_4_1_Core_glLineWidth);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glHint, "QOpenGLFunctions_4_1_Core.glHint(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glHint(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glHint(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glHint(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glHint, doc_QOpenGLFunctions_4_1_Core_glHint);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFrontFace, "QOpenGLFunctions_4_1_Core.glFrontFace(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFrontFace(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFrontFace(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glFrontFace(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFrontFace, doc_QOpenGLFunctions_4_1_Core_glFrontFace);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCullFace, "QOpenGLFunctions_4_1_Core.glCullFace(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCullFace(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCullFace(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glCullFace(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCullFace, doc_QOpenGLFunctions_4_1_Core_glCullFace);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIndexubv, "QOpenGLFunctions_4_1_Core.glIndexubv(sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIndexubv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIndexubv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 455 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a0, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glIndexubv(reinterpret_cast<const GLubyte *>(array));
#line 2384 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIndexubv, doc_QOpenGLFunctions_4_1_Core_glIndexubv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIndexub, "QOpenGLFunctions_4_1_Core.glIndexub(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIndexub(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIndexub(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLubyte a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glIndexub(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIndexub, doc_QOpenGLFunctions_4_1_Core_glIndexub);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsTexture, "QOpenGLFunctions_4_1_Core.glIsTexture(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsTexture(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsTexture(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsTexture, doc_QOpenGLFunctions_4_1_Core_glIsTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGenTextures, "QOpenGLFunctions_4_1_Core.glGenTextures(int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenTextures(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenTextures(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 466 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLuint *params = new GLuint[a0];
            
        sipCpp->glGenTextures(a0, params);
        
        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
        
        delete[] params;
#line 2489 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGenTextures, doc_QOpenGLFunctions_4_1_Core_glGenTextures);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDeleteTextures, "QOpenGLFunctions_4_1_Core.glDeleteTextures(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteTextures(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteTextures(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 477 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDeleteTextures(a0, reinterpret_cast<const GLuint *>(array));
#line 2527 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDeleteTextures, doc_QOpenGLFunctions_4_1_Core_glDeleteTextures);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindTexture, "QOpenGLFunctions_4_1_Core.glBindTexture(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindTexture(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindTexture(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindTexture, doc_QOpenGLFunctions_4_1_Core_glBindTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexSubImage2D, "QOpenGLFunctions_4_1_Core.glTexSubImage2D(int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLsizei a4;
        GLsizei a5;
        GLenum a6;
        GLenum a7;
        PyObject * a8;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
        {
            sipErrorState sipError = sipErrorNone;

#line 487 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a8, a7, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
#line 2605 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexSubImage2D, doc_QOpenGLFunctions_4_1_Core_glTexSubImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexSubImage1D, "QOpenGLFunctions_4_1_Core.glTexSubImage1D(int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLenum a4;
        GLenum a5;
        PyObject * a6;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6))
        {
            sipErrorState sipError = sipErrorNone;

#line 495 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a6, a5, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexSubImage1D(a0, a1, a2, a3, a4, a5, array);
#line 2653 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexSubImage1D, doc_QOpenGLFunctions_4_1_Core_glTexSubImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D, "QOpenGLFunctions_4_1_Core.glCopyTexSubImage2D(int, int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLint a5;
        GLsizei a6;
        GLsizei a7;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiiiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
        {
            sipCpp->glCopyTexSubImage2D(a0,a1,a2,a3,a4,a5,a6,a7);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCopyTexSubImage2D, doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D, "QOpenGLFunctions_4_1_Core.glCopyTexSubImage1D(int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLsizei a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glCopyTexSubImage1D(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCopyTexSubImage1D, doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCopyTexImage2D, "QOpenGLFunctions_4_1_Core.glCopyTexImage2D(int, int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        GLint a3;
        GLint a4;
        GLsizei a5;
        GLsizei a6;
        GLint a7;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuiiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
        {
            sipCpp->glCopyTexImage2D(a0,a1,a2,a3,a4,a5,a6,a7);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCopyTexImage2D, doc_QOpenGLFunctions_4_1_Core_glCopyTexImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCopyTexImage1D, "QOpenGLFunctions_4_1_Core.glCopyTexImage1D(int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        GLint a3;
        GLint a4;
        GLsizei a5;
        GLint a6;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6))
        {
            sipCpp->glCopyTexImage1D(a0,a1,a2,a3,a4,a5,a6);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCopyTexImage1D, doc_QOpenGLFunctions_4_1_Core_glCopyTexImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPolygonOffset, "QOpenGLFunctions_4_1_Core.glPolygonOffset(float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPolygonOffset(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPolygonOffset(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        GLfloat a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPolygonOffset(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPolygonOffset, doc_QOpenGLFunctions_4_1_Core_glPolygonOffset);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawElements, "QOpenGLFunctions_4_1_Core.glDrawElements(int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawElements(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawElements(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLsizei a1;
        GLenum a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 508 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a3, a2, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDrawElements(a0, a1, a2, array);
#line 2859 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawElements, doc_QOpenGLFunctions_4_1_Core_glDrawElements);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawArrays, "QOpenGLFunctions_4_1_Core.glDrawArrays(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawArrays(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawArrays(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLsizei a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glDrawArrays(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawArrays, doc_QOpenGLFunctions_4_1_Core_glDrawArrays);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D, "QOpenGLFunctions_4_1_Core.glCopyTexSubImage3D(int, int, int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLint a5;
        GLint a6;
        GLsizei a7;
        GLsizei a8;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiiiiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
        {
            sipCpp->glCopyTexSubImage3D(a0,a1,a2,a3,a4,a5,a6,a7,a8);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCopyTexSubImage3D, doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexSubImage3D, "QOpenGLFunctions_4_1_Core.glTexSubImage3D(int, int, int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexSubImage3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLsizei a5;
        GLsizei a6;
        GLsizei a7;
        GLenum a8;
        GLenum a9;
        PyObject * a10;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
        {
            sipErrorState sipError = sipErrorNone;

#line 518 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a10, a9, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexSubImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, array);
#line 2975 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexSubImage3D, doc_QOpenGLFunctions_4_1_Core_glTexSubImage3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexImage3D, "QOpenGLFunctions_4_1_Core.glTexImage3D(int, int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLsizei a4;
        GLsizei a5;
        GLint a6;
        GLenum a7;
        GLenum a8;
        PyObject * a9;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiiuuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
        {
            sipErrorState sipError = sipErrorNone;

#line 526 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a9, a8, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glTexImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, array);
#line 3026 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexImage3D, doc_QOpenGLFunctions_4_1_Core_glTexImage3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawRangeElements, "QOpenGLFunctions_4_1_Core.glDrawRangeElements(int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawRangeElements(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawRangeElements(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        GLuint a2;
        GLsizei a3;
        GLenum a4;
        PyObject * a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuuiuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipErrorState sipError = sipErrorNone;

#line 534 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a5, a4, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDrawRangeElements(a0, a1, a2, a3, a4, array);
#line 3073 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawRangeElements, doc_QOpenGLFunctions_4_1_Core_glDrawRangeElements);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendEquation, "QOpenGLFunctions_4_1_Core.glBlendEquation(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquation(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glBlendEquation(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendEquation, doc_QOpenGLFunctions_4_1_Core_glBlendEquation);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendColor, "QOpenGLFunctions_4_1_Core.glBlendColor(float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendColor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        GLfloat a1;
        GLfloat a2;
        GLfloat a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bffff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glBlendColor(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendColor, doc_QOpenGLFunctions_4_1_Core_glBlendColor);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D, "QOpenGLFunctions_4_1_Core.glCompressedTexSubImage1D(int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLenum a4;
        GLsizei a5;
        PyObject * a6;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiuiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6))
        {
            sipErrorState sipError = sipErrorNone;

#line 544 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a6, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexSubImage1D(a0, a1, a2, a3, a4, a5, array);
#line 3179 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexSubImage1D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D, "QOpenGLFunctions_4_1_Core.glCompressedTexSubImage2D(int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLsizei a4;
        GLsizei a5;
        GLenum a6;
        GLsizei a7;
        PyObject * a8;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiuiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
        {
            sipErrorState sipError = sipErrorNone;

#line 553 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a8, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexSubImage2D(a0, a1, a2, a3, a4, a5, a6, a7, array);
#line 3230 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexSubImage2D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D, "QOpenGLFunctions_4_1_Core.glCompressedTexSubImage3D(int, int, int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLsizei a5;
        GLsizei a6;
        GLsizei a7;
        GLenum a8;
        GLsizei a9;
        PyObject * a10;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiiiuiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
        {
            sipErrorState sipError = sipErrorNone;

#line 562 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a10, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexSubImage3D(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
                array);
#line 3284 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexSubImage3D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D, "QOpenGLFunctions_4_1_Core.glCompressedTexImage1D(int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        GLsizei a3;
        GLint a4;
        GLsizei a5;
        PyObject * a6;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiuiiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6))
        {
            sipErrorState sipError = sipErrorNone;

#line 572 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a6, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexImage1D(a0, a1, a2, a3, a4, a5, array);
#line 3333 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexImage1D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D, "QOpenGLFunctions_4_1_Core.glCompressedTexImage2D(int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        GLsizei a3;
        GLsizei a4;
        GLint a5;
        GLsizei a6;
        PyObject * a7;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiuiiiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
        {
            sipErrorState sipError = sipErrorNone;

#line 581 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a7, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexImage2D(a0, a1, a2, a3, a4, a5, a6, array);
#line 3383 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexImage2D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D, "QOpenGLFunctions_4_1_Core.glCompressedTexImage3D(int, int, int, int, int, int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLenum a2;
        GLsizei a3;
        GLsizei a4;
        GLsizei a5;
        GLint a6;
        GLsizei a7;
        PyObject * a8;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiuiiiiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
        {
            sipErrorState sipError = sipErrorNone;

#line 590 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a8, GL_UNSIGNED_BYTE,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glCompressedTexImage3D(a0, a1, a2, a3, a4, a5, a6, a7, array);
#line 3434 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompressedTexImage3D, doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glSampleCoverage, "QOpenGLFunctions_4_1_Core.glSampleCoverage(float, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glSampleCoverage(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glSampleCoverage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        GLboolean a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BfM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glSampleCoverage(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glSampleCoverage, doc_QOpenGLFunctions_4_1_Core_glSampleCoverage);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glActiveTexture, "QOpenGLFunctions_4_1_Core.glActiveTexture(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glActiveTexture(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glActiveTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glActiveTexture(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glActiveTexture, doc_QOpenGLFunctions_4_1_Core_glActiveTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPointParameteriv, "QOpenGLFunctions_4_1_Core.glPointParameteriv(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameteriv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameteriv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 601 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glPointParameteriv(a0, reinterpret_cast<const GLint *>(array));
#line 3532 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPointParameteriv, doc_QOpenGLFunctions_4_1_Core_glPointParameteriv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPointParameteri, "QOpenGLFunctions_4_1_Core.glPointParameteri(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameteri(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameteri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPointParameteri(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPointParameteri, doc_QOpenGLFunctions_4_1_Core_glPointParameteri);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPointParameterfv, "QOpenGLFunctions_4_1_Core.glPointParameterfv(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameterfv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameterfv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 610 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glPointParameterfv(a0, reinterpret_cast<const GLfloat *>(array));
#line 3603 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPointParameterfv, doc_QOpenGLFunctions_4_1_Core_glPointParameterfv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPointParameterf, "QOpenGLFunctions_4_1_Core.glPointParameterf(int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameterf(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPointParameterf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLfloat a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPointParameterf(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPointParameterf, doc_QOpenGLFunctions_4_1_Core_glPointParameterf);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate, "QOpenGLFunctions_4_1_Core.glBlendFuncSeparate(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLenum a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glBlendFuncSeparate(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendFuncSeparate, doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv, "QOpenGLFunctions_4_1_Core.glGetBufferParameteriv(int, int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glGetBufferParameteriv(a0,a1,&a2);

            return SIPLong_FromLong(a2);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetBufferParameteriv, doc_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUnmapBuffer, "QOpenGLFunctions_4_1_Core.glUnmapBuffer(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUnmapBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUnmapBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glUnmapBuffer(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUnmapBuffer, doc_QOpenGLFunctions_4_1_Core_glUnmapBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBufferSubData, "QOpenGLFunctions_4_1_Core.glBufferSubData(int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBufferSubData(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBufferSubData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLintptr a1;
        GLsizeiptr a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BullP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 622 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array;
        
        if (a3 == Py_None)
            array = 0;
        else
            array = qpyopengl_value_array(&sipError, a3, GL_UNSIGNED_BYTE, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glBufferSubData(a0, a1, a2, array);
#line 3771 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBufferSubData, doc_QOpenGLFunctions_4_1_Core_glBufferSubData);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBufferData, "QOpenGLFunctions_4_1_Core.glBufferData(int, int, sequence-or-buffer, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBufferData(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBufferData(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLsizeiptr a1;
        PyObject * a2;
        GLenum a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BulP0u", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 635 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array;
        
        if (a2 == Py_None)
            array = 0;
        else
            array = qpyopengl_value_array(&sipError, a2, GL_UNSIGNED_BYTE, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glBufferData(a0, a1, array, a3);
#line 3821 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBufferData, doc_QOpenGLFunctions_4_1_Core_glBufferData);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsBuffer, "QOpenGLFunctions_4_1_Core.glIsBuffer(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsBuffer(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsBuffer, doc_QOpenGLFunctions_4_1_Core_glIsBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGenBuffers, "QOpenGLFunctions_4_1_Core.glGenBuffers(int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenBuffers(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 649 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLuint *params = new GLuint[a0];
            
        sipCpp->glGenBuffers(a0, params);
        
        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
        
        delete[] params;
#line 3899 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGenBuffers, doc_QOpenGLFunctions_4_1_Core_glGenBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDeleteBuffers, "QOpenGLFunctions_4_1_Core.glDeleteBuffers(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteBuffers(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 660 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDeleteBuffers(a0, reinterpret_cast<const GLuint *>(array));
#line 3937 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDeleteBuffers, doc_QOpenGLFunctions_4_1_Core_glDeleteBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindBuffer, "QOpenGLFunctions_4_1_Core.glBindBuffer(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindBuffer(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindBuffer, doc_QOpenGLFunctions_4_1_Core_glBindBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetQueryiv, "QOpenGLFunctions_4_1_Core.glGetQueryiv(int, int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetQueryiv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetQueryiv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glGetQueryiv(a0,a1,&a2);

            return SIPLong_FromLong(a2);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetQueryiv, doc_QOpenGLFunctions_4_1_Core_glGetQueryiv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEndQuery, "QOpenGLFunctions_4_1_Core.glEndQuery(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndQuery(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glEndQuery(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEndQuery, doc_QOpenGLFunctions_4_1_Core_glEndQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBeginQuery, "QOpenGLFunctions_4_1_Core.glBeginQuery(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginQuery(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBeginQuery(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBeginQuery, doc_QOpenGLFunctions_4_1_Core_glBeginQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsQuery, "QOpenGLFunctions_4_1_Core.glIsQuery(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsQuery(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsQuery(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsQuery(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsQuery, doc_QOpenGLFunctions_4_1_Core_glIsQuery);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDeleteQueries, "QOpenGLFunctions_4_1_Core.glDeleteQueries(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteQueries(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteQueries(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 674 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDeleteQueries(a0, reinterpret_cast<const GLuint *>(array));
#line 4124 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDeleteQueries, doc_QOpenGLFunctions_4_1_Core_glDeleteQueries);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGenQueries, "QOpenGLFunctions_4_1_Core.glGenQueries(int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenQueries(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenQueries(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            int sipIsErr = 0;

#line 683 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLuint *params = new GLuint[a0];
            
        sipCpp->glGenQueries(a0, params);
        
        a1 = qpyopengl_from_GLuint(&sipIsErr, params, a0);
        
        delete[] params;
#line 4170 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a1;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGenQueries, doc_QOpenGLFunctions_4_1_Core_glGenQueries);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribPointer, "QOpenGLFunctions_4_1_Core.glVertexAttribPointer(int, int, int, int, int, sequence-or-buffer-or-offset)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribPointer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribPointer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLenum a2;
        GLboolean a3;
        GLsizei a4;
        PyObject * a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiuMiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipErrorState sipError = sipErrorNone;

#line 694 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array_cached(&sipError, a5, a2, sipSelf,
                "VertexAttribPointer", a0);
        
        if (sipError == sipErrorNone)
            sipCpp->glVertexAttribPointer(a0, a1, a2, a3, a4, array);
#line 4212 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribPointer, doc_QOpenGLFunctions_4_1_Core_glVertexAttribPointer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glValidateProgram, "QOpenGLFunctions_4_1_Core.glValidateProgram(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glValidateProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glValidateProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glValidateProgram(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glValidateProgram, doc_QOpenGLFunctions_4_1_Core_glValidateProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv, "QOpenGLFunctions_4_1_Core.glUniformMatrix4fv(int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        GLboolean a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiMP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 704 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniformMatrix4fv(a0, a1, a2,
                    reinterpret_cast<const GLfloat *>(array));
#line 4285 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniformMatrix4fv, doc_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv, "QOpenGLFunctions_4_1_Core.glUniformMatrix3fv(int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        GLboolean a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiMP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 713 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniformMatrix3fv(a0, a1, a2,
                    reinterpret_cast<const GLfloat *>(array));
#line 4331 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniformMatrix3fv, doc_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv, "QOpenGLFunctions_4_1_Core.glUniformMatrix2fv(int, int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        GLboolean a2;
        PyObject * a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiMP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipErrorState sipError = sipErrorNone;

#line 722 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a3, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniformMatrix2fv(a0, a1, a2,
                    reinterpret_cast<const GLfloat *>(array));
#line 4377 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniformMatrix2fv, doc_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4iv, "QOpenGLFunctions_4_1_Core.glUniform4iv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4iv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4iv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 731 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform4iv(a0, a1, reinterpret_cast<const GLint *>(array));
#line 4421 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4iv, doc_QOpenGLFunctions_4_1_Core_glUniform4iv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3iv, "QOpenGLFunctions_4_1_Core.glUniform3iv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3iv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3iv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 739 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform3iv(a0, a1, reinterpret_cast<const GLint *>(array));
#line 4465 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3iv, doc_QOpenGLFunctions_4_1_Core_glUniform3iv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2iv, "QOpenGLFunctions_4_1_Core.glUniform2iv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2iv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2iv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 747 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform2iv(a0, a1, reinterpret_cast<const GLint *>(array));
#line 4509 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2iv, doc_QOpenGLFunctions_4_1_Core_glUniform2iv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1iv, "QOpenGLFunctions_4_1_Core.glUniform1iv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1iv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1iv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 755 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_INT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform1iv(a0, a1, reinterpret_cast<const GLint *>(array));
#line 4553 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1iv, doc_QOpenGLFunctions_4_1_Core_glUniform1iv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4fv, "QOpenGLFunctions_4_1_Core.glUniform4fv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 763 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform4fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
#line 4597 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4fv, doc_QOpenGLFunctions_4_1_Core_glUniform4fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3fv, "QOpenGLFunctions_4_1_Core.glUniform3fv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 771 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform3fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
#line 4641 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3fv, doc_QOpenGLFunctions_4_1_Core_glUniform3fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2fv, "QOpenGLFunctions_4_1_Core.glUniform2fv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 779 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform2fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
#line 4685 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2fv, doc_QOpenGLFunctions_4_1_Core_glUniform2fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1fv, "QOpenGLFunctions_4_1_Core.glUniform1fv(int, int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1fv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1fv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLsizei a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipErrorState sipError = sipErrorNone;

#line 787 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a2, GL_FLOAT, sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glUniform1fv(a0, a1, reinterpret_cast<const GLfloat *>(array));
#line 4729 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1fv, doc_QOpenGLFunctions_4_1_Core_glUniform1fv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4i, "QOpenGLFunctions_4_1_Core.glUniform4i(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glUniform4i(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4i, doc_QOpenGLFunctions_4_1_Core_glUniform4i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3i, "QOpenGLFunctions_4_1_Core.glUniform3i(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glUniform3i(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3i, doc_QOpenGLFunctions_4_1_Core_glUniform3i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2i, "QOpenGLFunctions_4_1_Core.glUniform2i(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUniform2i(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2i, doc_QOpenGLFunctions_4_1_Core_glUniform2i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1i, "QOpenGLFunctions_4_1_Core.glUniform1i(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glUniform1i(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1i, doc_QOpenGLFunctions_4_1_Core_glUniform1i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4f, "QOpenGLFunctions_4_1_Core.glUniform4f(int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLfloat a1;
        GLfloat a2;
        GLfloat a3;
        GLfloat a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biffff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glUniform4f(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4f, doc_QOpenGLFunctions_4_1_Core_glUniform4f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3f, "QOpenGLFunctions_4_1_Core.glUniform3f(int, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLfloat a1;
        GLfloat a2;
        GLfloat a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bifff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glUniform3f(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3f, doc_QOpenGLFunctions_4_1_Core_glUniform3f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2f, "QOpenGLFunctions_4_1_Core.glUniform2f(int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLfloat a1;
        GLfloat a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUniform2f(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2f, doc_QOpenGLFunctions_4_1_Core_glUniform2f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1f, "QOpenGLFunctions_4_1_Core.glUniform1f(int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLfloat a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bif", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glUniform1f(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1f, doc_QOpenGLFunctions_4_1_Core_glUniform1f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUseProgram, "QOpenGLFunctions_4_1_Core.glUseProgram(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUseProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUseProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glUseProgram(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUseProgram, doc_QOpenGLFunctions_4_1_Core_glUseProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glLinkProgram, "QOpenGLFunctions_4_1_Core.glLinkProgram(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glLinkProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glLinkProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glLinkProgram(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glLinkProgram, doc_QOpenGLFunctions_4_1_Core_glLinkProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsShader, "QOpenGLFunctions_4_1_Core.glIsShader(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsShader(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsShader, doc_QOpenGLFunctions_4_1_Core_glIsShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsProgram, "QOpenGLFunctions_4_1_Core.glIsProgram(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsProgram(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsProgram, doc_QOpenGLFunctions_4_1_Core_glIsProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv, "QOpenGLFunctions_4_1_Core.glGetVertexAttribiv(int, int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 807 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint params[4];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        case GL_CURRENT_VERTEX_ATTRIB:
            nr_params = 4;
            break;
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetVertexAttribiv(a0, a1, params);
        
        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
#line 5139 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetVertexAttribiv, doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv, "QOpenGLFunctions_4_1_Core.glGetVertexAttribfv(int, int) -> float-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 827 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLfloat params[4];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        case GL_CURRENT_VERTEX_ATTRIB:
            nr_params = 4;
            break;
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetVertexAttribfv(a0, a1, params);
        
        a2 = qpyopengl_from_GLfloat(&sipIsErr, params, nr_params);
#line 5189 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetVertexAttribfv, doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv, "QOpenGLFunctions_4_1_Core.glGetVertexAttribdv(int, int) -> double-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 847 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLdouble params[4];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        case GL_CURRENT_VERTEX_ATTRIB:
            nr_params = 4;
            break;
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetVertexAttribdv(a0, a1, params);
        
        a2 = qpyopengl_from_GLdouble(&sipIsErr, params, nr_params);
#line 5239 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetVertexAttribdv, doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetUniformLocation, "QOpenGLFunctions_4_1_Core.glGetUniformLocation(int, str) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetUniformLocation(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetUniformLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        const GLchar* a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bus", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            GLint sipRes;

            sipRes = sipCpp->glGetUniformLocation(a0,a1);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetUniformLocation, doc_QOpenGLFunctions_4_1_Core_glGetUniformLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetShaderSource, "QOpenGLFunctions_4_1_Core.glGetShaderSource(int) -> str");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderSource(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderSource(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;

#line 868 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint bufsize;
        
        sipCpp->glGetShaderiv(a0, GL_SHADER_SOURCE_LENGTH, &bufsize);
        
        if (bufsize > 0)
        {
            GLchar *source = new GLchar[bufsize];
        
            sipCpp->glGetShaderSource(a0, bufsize, 0, source);
            sipRes = SIPBytes_FromString(source);
        
            delete[] source;
        }
        else
        {
            sipRes = SIPBytes_FromString("");
        }
#line 5317 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetShaderSource, doc_QOpenGLFunctions_4_1_Core_glGetShaderSource);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog, "QOpenGLFunctions_4_1_Core.glGetShaderInfoLog(int) -> str");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;

#line 889 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint bufsize;
        
        sipCpp->glGetShaderiv(a0, GL_INFO_LOG_LENGTH, &bufsize);
        
        if (bufsize > 0)
        {
            GLchar *log = new GLchar[bufsize];
        
            sipCpp->glGetShaderInfoLog(a0, bufsize, 0, log);
            sipRes = SIPBytes_FromString(log);
        
            delete[] log;
        }
        else
        {
            sipRes = SIPBytes_FromString("");
        }
#line 5363 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetShaderInfoLog, doc_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetShaderiv, "QOpenGLFunctions_4_1_Core.glGetShaderiv(int, int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderiv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetShaderiv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glGetShaderiv(a0,a1,&a2);

            return SIPLong_FromLong(a2);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetShaderiv, doc_QOpenGLFunctions_4_1_Core_glGetShaderiv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog, "QOpenGLFunctions_4_1_Core.glGetProgramInfoLog(int) -> str");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;

#line 911 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint bufsize;
        
        sipCpp->glGetProgramiv(a0, GL_INFO_LOG_LENGTH, &bufsize);
        
        if (bufsize > 0)
        {
            GLchar *log = new GLchar[bufsize];
        
            sipCpp->glGetProgramInfoLog(a0, bufsize, 0, log);
            sipRes = SIPBytes_FromString(log);
        
            delete[] log;
        }
        else
        {
            sipRes = SIPBytes_FromString("");
        }
#line 5437 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetProgramInfoLog, doc_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetProgramiv, "QOpenGLFunctions_4_1_Core.glGetProgramiv(int, int) -> int-or-tuple");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetProgramiv(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetProgramiv(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        PyObject * a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            int sipIsErr = 0;

#line 932 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint params[3];
        SIP_SSIZE_T nr_params;
        
        switch (a1)
        {
        #if defined(GL_COMPUTE_LOCAL_WORK_SIZE)
        case GL_COMPUTE_LOCAL_WORK_SIZE:
            nr_params = 3;
            break;
        #endif
        
        default:
            nr_params = 1;
        }
        
        sipCpp->glGetProgramiv(a0, a1, params);
        
        a2 = qpyopengl_from_GLint(&sipIsErr, params, nr_params);
#line 5486 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return a2;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetProgramiv, doc_QOpenGLFunctions_4_1_Core_glGetProgramiv);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetAttribLocation, "QOpenGLFunctions_4_1_Core.glGetAttribLocation(int, str) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetAttribLocation(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetAttribLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        const GLchar* a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bus", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            GLint sipRes;

            sipRes = sipCpp->glGetAttribLocation(a0,a1);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetAttribLocation, doc_QOpenGLFunctions_4_1_Core_glGetAttribLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetAttachedShaders, "QOpenGLFunctions_4_1_Core.glGetAttachedShaders(int) -> tuple-of-int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetAttachedShaders(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetAttachedShaders(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            PyObject * sipRes = 0;
            int sipIsErr = 0;

#line 955 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint nr_shaders;
        
        sipCpp->glGetProgramiv(a0, GL_ATTACHED_SHADERS, &nr_shaders);
        
        if (nr_shaders < 1)
        {
            sipRes = PyTuple_New(0);
        }
        else
        {
            GLuint *shaders = new GLuint[nr_shaders];
        
            sipCpp->glGetAttachedShaders(a0, nr_shaders, 0, shaders);
        
            sipRes = PyTuple_New(nr_shaders);
        
            if (sipRes)
            {
                for (GLint i = 0; i < nr_shaders; ++i)
                {
                    PyObject *itm = SIPLong_FromLong(shaders[i]);
                    
                    if (!itm)
                    {
                        Py_DECREF(sipRes);
                        sipRes = 0;
                        break;
                    }
                    
                    PyTuple_SET_ITEM(sipRes, i, itm);
                }
            }
        
            delete[] shaders;
        }
        
        if (!sipRes)
            sipIsErr = 1;
#line 5586 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetAttachedShaders, doc_QOpenGLFunctions_4_1_Core_glGetAttachedShaders);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetActiveUniform, "QOpenGLFunctions_4_1_Core.glGetActiveUniform(int, int) -> str, int, int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetActiveUniform(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetActiveUniform(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            PyObject * sipRes = 0;
            int sipIsErr = 0;

#line 997 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint bufsize;
        
        sipCpp->glGetProgramiv(a0, GL_ACTIVE_UNIFORM_MAX_LENGTH, &bufsize);
        
        GLchar *name = new GLchar[bufsize];
        GLint size;
        GLenum type;
        
        sipCpp->glGetActiveUniform(a0, a1, bufsize, 0, &size, &type, name);
        
        sipRes = Py_BuildValue("siI", name, size, type);
        
        if (!sipRes)
            sipIsErr = 1;
        
        delete[] name;
#line 5636 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetActiveUniform, doc_QOpenGLFunctions_4_1_Core_glGetActiveUniform);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGetActiveAttrib, "QOpenGLFunctions_4_1_Core.glGetActiveAttrib(int, int) -> str, int, int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetActiveAttrib(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGetActiveAttrib(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            PyObject * sipRes = 0;
            int sipIsErr = 0;

#line 1017 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        GLint bufsize;
        
        sipCpp->glGetProgramiv(a0, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &bufsize);
        
        GLchar *name = new GLchar[bufsize];
        GLint size;
        GLenum type;
        
        sipCpp->glGetActiveAttrib(a0, a1, bufsize, 0, &size, &type, name);
        
        sipRes = Py_BuildValue("siI", name, size, type);
        
        if (!sipRes)
            sipIsErr = 1;
        
        delete[] name;
#line 5686 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipIsErr)
                return 0;

            return sipRes;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGetActiveAttrib, doc_QOpenGLFunctions_4_1_Core_glGetActiveAttrib);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray, "QOpenGLFunctions_4_1_Core.glEnableVertexAttribArray(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glEnableVertexAttribArray(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEnableVertexAttribArray, doc_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray, "QOpenGLFunctions_4_1_Core.glDisableVertexAttribArray(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDisableVertexAttribArray(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDisableVertexAttribArray, doc_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDetachShader, "QOpenGLFunctions_4_1_Core.glDetachShader(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDetachShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDetachShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glDetachShader(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDetachShader, doc_QOpenGLFunctions_4_1_Core_glDetachShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDeleteShader, "QOpenGLFunctions_4_1_Core.glDeleteShader(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDeleteShader(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDeleteShader, doc_QOpenGLFunctions_4_1_Core_glDeleteShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDeleteProgram, "QOpenGLFunctions_4_1_Core.glDeleteProgram(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDeleteProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glDeleteProgram(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDeleteProgram, doc_QOpenGLFunctions_4_1_Core_glDeleteProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCreateShader, "QOpenGLFunctions_4_1_Core.glCreateShader(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCreateShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCreateShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLuint sipRes;

            sipRes = sipCpp->glCreateShader(a0);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCreateShader, doc_QOpenGLFunctions_4_1_Core_glCreateShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCreateProgram, "QOpenGLFunctions_4_1_Core.glCreateProgram() -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCreateProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCreateProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            GLuint sipRes;

            sipRes = sipCpp->glCreateProgram();

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCreateProgram, doc_QOpenGLFunctions_4_1_Core_glCreateProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCompileShader, "QOpenGLFunctions_4_1_Core.glCompileShader(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompileShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCompileShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glCompileShader(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCompileShader, doc_QOpenGLFunctions_4_1_Core_glCompileShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindAttribLocation, "QOpenGLFunctions_4_1_Core.glBindAttribLocation(int, int, str)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindAttribLocation(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindAttribLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        const GLchar* a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buus", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glBindAttribLocation(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindAttribLocation, doc_QOpenGLFunctions_4_1_Core_glBindAttribLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glAttachShader, "QOpenGLFunctions_4_1_Core.glAttachShader(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glAttachShader(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glAttachShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glAttachShader(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glAttachShader, doc_QOpenGLFunctions_4_1_Core_glAttachShader);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate, "QOpenGLFunctions_4_1_Core.glStencilMaskSeparate(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glStencilMaskSeparate(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilMaskSeparate, doc_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate, "QOpenGLFunctions_4_1_Core.glStencilFuncSeparate(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLint a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuiu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glStencilFuncSeparate(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilFuncSeparate, doc_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glStencilOpSeparate, "QOpenGLFunctions_4_1_Core.glStencilOpSeparate(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilOpSeparate(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glStencilOpSeparate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLenum a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glStencilOpSeparate(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glStencilOpSeparate, doc_QOpenGLFunctions_4_1_Core_glStencilOpSeparate);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawBuffers, "QOpenGLFunctions_4_1_Core.glDrawBuffers(int, sequence-or-buffer)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawBuffers(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLsizei a0;
        PyObject * a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 1050 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/sip/_QOpenGLFunctions_4_1_Core/qopenglfunctions_4_1_core.sip"
        const GLvoid *array = qpyopengl_value_array(&sipError, a1, GL_UNSIGNED_INT,
                sipSelf);
        
        if (sipError == sipErrorNone)
            sipCpp->glDrawBuffers(a0, reinterpret_cast<const GLenum *>(array));
#line 6087 "/usr/src/ports/python-pyqt5/python-pyqt5-5.5-1.i686/build/_QOpenGLFunctions_4_1_Core/sip_QOpenGLFunctions_4_1_Corepart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawBuffers, doc_QOpenGLFunctions_4_1_Core_glDrawBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate, "QOpenGLFunctions_4_1_Core.glBlendEquationSeparate(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBlendEquationSeparate(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendEquationSeparate, doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsVertexArray, "QOpenGLFunctions_4_1_Core.glIsVertexArray(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsVertexArray(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsVertexArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsVertexArray(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsVertexArray, doc_QOpenGLFunctions_4_1_Core_glIsVertexArray);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindVertexArray, "QOpenGLFunctions_4_1_Core.glBindVertexArray(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindVertexArray(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindVertexArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glBindVertexArray(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindVertexArray, doc_QOpenGLFunctions_4_1_Core_glBindVertexArray);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer, "QOpenGLFunctions_4_1_Core.glFramebufferTextureLayer(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        GLint a3;
        GLint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glFramebufferTextureLayer(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferTextureLayer, doc_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample, "QOpenGLFunctions_4_1_Core.glRenderbufferStorageMultisample(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLsizei a1;
        GLenum a2;
        GLsizei a3;
        GLsizei a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glRenderbufferStorageMultisample(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glRenderbufferStorageMultisample, doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlitFramebuffer, "QOpenGLFunctions_4_1_Core.glBlitFramebuffer(int, int, int, int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlitFramebuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlitFramebuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLint a5;
        GLint a6;
        GLint a7;
        GLbitfield a8;
        GLenum a9;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biiiiiiiiuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
        {
            sipCpp->glBlitFramebuffer(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlitFramebuffer, doc_QOpenGLFunctions_4_1_Core_glBlitFramebuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glGenerateMipmap, "QOpenGLFunctions_4_1_Core.glGenerateMipmap(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenerateMipmap(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glGenerateMipmap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glGenerateMipmap(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glGenerateMipmap, doc_QOpenGLFunctions_4_1_Core_glGenerateMipmap);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer, "QOpenGLFunctions_4_1_Core.glFramebufferRenderbuffer(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glFramebufferRenderbuffer(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferRenderbuffer, doc_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D, "QOpenGLFunctions_4_1_Core.glFramebufferTexture3D(int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLuint a3;
        GLint a4;
        GLint a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuuii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glFramebufferTexture3D(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferTexture3D, doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D, "QOpenGLFunctions_4_1_Core.glFramebufferTexture2D(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLuint a3;
        GLint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glFramebufferTexture2D(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferTexture2D, doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D, "QOpenGLFunctions_4_1_Core.glFramebufferTexture1D(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLenum a2;
        GLuint a3;
        GLint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glFramebufferTexture1D(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferTexture1D, doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus, "QOpenGLFunctions_4_1_Core.glCheckFramebufferStatus(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLenum sipRes;

            sipRes = sipCpp->glCheckFramebufferStatus(a0);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glCheckFramebufferStatus, doc_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindFramebuffer, "QOpenGLFunctions_4_1_Core.glBindFramebuffer(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindFramebuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindFramebuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindFramebuffer(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindFramebuffer, doc_QOpenGLFunctions_4_1_Core_glBindFramebuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsFramebuffer, "QOpenGLFunctions_4_1_Core.glIsFramebuffer(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsFramebuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsFramebuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsFramebuffer(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsFramebuffer, doc_QOpenGLFunctions_4_1_Core_glIsFramebuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorage, "QOpenGLFunctions_4_1_Core.glRenderbufferStorage(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorage(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLsizei a2;
        GLsizei a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glRenderbufferStorage(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glRenderbufferStorage, doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorage);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindRenderbuffer, "QOpenGLFunctions_4_1_Core.glBindRenderbuffer(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindRenderbuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindRenderbuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindRenderbuffer(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindRenderbuffer, doc_QOpenGLFunctions_4_1_Core_glBindRenderbuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsRenderbuffer, "QOpenGLFunctions_4_1_Core.glIsRenderbuffer(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsRenderbuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsRenderbuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsRenderbuffer(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsRenderbuffer, doc_QOpenGLFunctions_4_1_Core_glIsRenderbuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClearBufferfi, "QOpenGLFunctions_4_1_Core.glClearBufferfi(int, int, float, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearBufferfi(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearBufferfi(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLfloat a2;
        GLint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buifi", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glClearBufferfi(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClearBufferfi, doc_QOpenGLFunctions_4_1_Core_glClearBufferfi);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4ui, "QOpenGLFunctions_4_1_Core.glUniform4ui(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLuint a1;
        GLuint a2;
        GLuint a3;
        GLuint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biuuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glUniform4ui(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4ui, doc_QOpenGLFunctions_4_1_Core_glUniform4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3ui, "QOpenGLFunctions_4_1_Core.glUniform3ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLuint a1;
        GLuint a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glUniform3ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3ui, doc_QOpenGLFunctions_4_1_Core_glUniform3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2ui, "QOpenGLFunctions_4_1_Core.glUniform2ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLuint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUniform2ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2ui, doc_QOpenGLFunctions_4_1_Core_glUniform2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1ui, "QOpenGLFunctions_4_1_Core.glUniform1ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glUniform1ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1ui, doc_QOpenGLFunctions_4_1_Core_glUniform1ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEndConditionalRender, "QOpenGLFunctions_4_1_Core.glEndConditionalRender()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndConditionalRender(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndConditionalRender(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glEndConditionalRender();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEndConditionalRender, doc_QOpenGLFunctions_4_1_Core_glEndConditionalRender);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBeginConditionalRender, "QOpenGLFunctions_4_1_Core.glBeginConditionalRender(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginConditionalRender(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginConditionalRender(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBeginConditionalRender(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBeginConditionalRender, doc_QOpenGLFunctions_4_1_Core_glBeginConditionalRender);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClampColor, "QOpenGLFunctions_4_1_Core.glClampColor(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClampColor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClampColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glClampColor(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClampColor, doc_QOpenGLFunctions_4_1_Core_glClampColor);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindBufferBase, "QOpenGLFunctions_4_1_Core.glBindBufferBase(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindBufferBase(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindBufferBase(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glBindBufferBase(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindBufferBase, doc_QOpenGLFunctions_4_1_Core_glBindBufferBase);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEndTransformFeedback, "QOpenGLFunctions_4_1_Core.glEndTransformFeedback()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glEndTransformFeedback();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEndTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glEndTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback, "QOpenGLFunctions_4_1_Core.glBeginTransformFeedback(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glBeginTransformFeedback(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBeginTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsEnabledi, "QOpenGLFunctions_4_1_Core.glIsEnabledi(int, int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsEnabledi(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsEnabledi(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsEnabledi(a0,a1);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsEnabledi, doc_QOpenGLFunctions_4_1_Core_glIsEnabledi);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDisablei, "QOpenGLFunctions_4_1_Core.glDisablei(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisablei(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDisablei(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glDisablei(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDisablei, doc_QOpenGLFunctions_4_1_Core_glDisablei);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEnablei, "QOpenGLFunctions_4_1_Core.glEnablei(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnablei(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEnablei(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glEnablei(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEnablei, doc_QOpenGLFunctions_4_1_Core_glEnablei);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glColorMaski, "QOpenGLFunctions_4_1_Core.glColorMaski(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorMaski(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorMaski(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLboolean a1;
        GLboolean a2;
        GLboolean a3;
        GLboolean a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuMMMM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glColorMaski(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glColorMaski, doc_QOpenGLFunctions_4_1_Core_glColorMaski);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniformBlockBinding, "QOpenGLFunctions_4_1_Core.glUniformBlockBinding(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformBlockBinding(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniformBlockBinding(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUniformBlockBinding(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniformBlockBinding, doc_QOpenGLFunctions_4_1_Core_glUniformBlockBinding);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex, "QOpenGLFunctions_4_1_Core.glPrimitiveRestartIndex(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glPrimitiveRestartIndex(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPrimitiveRestartIndex, doc_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexBuffer, "QOpenGLFunctions_4_1_Core.glTexBuffer(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexBuffer(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glTexBuffer(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexBuffer, doc_QOpenGLFunctions_4_1_Core_glTexBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced, "QOpenGLFunctions_4_1_Core.glDrawArraysInstanced(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        GLsizei a2;
        GLsizei a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glDrawArraysInstanced(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawArraysInstanced, doc_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glSampleMaski, "QOpenGLFunctions_4_1_Core.glSampleMaski(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glSampleMaski(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glSampleMaski(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLbitfield a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glSampleMaski(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glSampleMaski, doc_QOpenGLFunctions_4_1_Core_glSampleMaski);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample, "QOpenGLFunctions_4_1_Core.glTexImage3DMultisample(int, int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLsizei a1;
        GLint a2;
        GLsizei a3;
        GLsizei a4;
        GLsizei a5;
        GLboolean a6;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiiM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5, &a6))
        {
            sipCpp->glTexImage3DMultisample(a0,a1,a2,a3,a4,a5,a6);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexImage3DMultisample, doc_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample, "QOpenGLFunctions_4_1_Core.glTexImage2DMultisample(int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLsizei a1;
        GLint a2;
        GLsizei a3;
        GLsizei a4;
        GLboolean a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuiiiiM", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glTexImage2DMultisample(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexImage2DMultisample, doc_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProvokingVertex, "QOpenGLFunctions_4_1_Core.glProvokingVertex(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProvokingVertex(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProvokingVertex(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glProvokingVertex(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProvokingVertex, doc_QOpenGLFunctions_4_1_Core_glProvokingVertex);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture, "QOpenGLFunctions_4_1_Core.glFramebufferTexture(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        GLint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glFramebufferTexture(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glFramebufferTexture, doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui, "QOpenGLFunctions_4_1_Core.glVertexAttribP4ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLboolean a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuMu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glVertexAttribP4ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribP4ui, doc_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui, "QOpenGLFunctions_4_1_Core.glVertexAttribP3ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLboolean a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuMu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glVertexAttribP3ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribP3ui, doc_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui, "QOpenGLFunctions_4_1_Core.glVertexAttribP2ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLboolean a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuMu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glVertexAttribP2ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribP2ui, doc_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui, "QOpenGLFunctions_4_1_Core.glVertexAttribP1ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLboolean a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BuuMu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glVertexAttribP1ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribP1ui, doc_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui, "QOpenGLFunctions_4_1_Core.glSecondaryColorP3ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glSecondaryColorP3ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glSecondaryColorP3ui, doc_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glColorP4ui, "QOpenGLFunctions_4_1_Core.glColorP4ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorP4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorP4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glColorP4ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glColorP4ui, doc_QOpenGLFunctions_4_1_Core_glColorP4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glColorP3ui, "QOpenGLFunctions_4_1_Core.glColorP3ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glColorP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glColorP3ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glColorP3ui, doc_QOpenGLFunctions_4_1_Core_glColorP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glNormalP3ui, "QOpenGLFunctions_4_1_Core.glNormalP3ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glNormalP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glNormalP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glNormalP3ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glNormalP3ui, doc_QOpenGLFunctions_4_1_Core_glNormalP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui, "QOpenGLFunctions_4_1_Core.glMultiTexCoordP4ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glMultiTexCoordP4ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glMultiTexCoordP4ui, doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui, "QOpenGLFunctions_4_1_Core.glMultiTexCoordP3ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glMultiTexCoordP3ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glMultiTexCoordP3ui, doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui, "QOpenGLFunctions_4_1_Core.glMultiTexCoordP2ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glMultiTexCoordP2ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glMultiTexCoordP2ui, doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui, "QOpenGLFunctions_4_1_Core.glMultiTexCoordP1ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLenum a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glMultiTexCoordP1ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glMultiTexCoordP1ui, doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexCoordP4ui, "QOpenGLFunctions_4_1_Core.glTexCoordP4ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glTexCoordP4ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexCoordP4ui, doc_QOpenGLFunctions_4_1_Core_glTexCoordP4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexCoordP3ui, "QOpenGLFunctions_4_1_Core.glTexCoordP3ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glTexCoordP3ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexCoordP3ui, doc_QOpenGLFunctions_4_1_Core_glTexCoordP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexCoordP2ui, "QOpenGLFunctions_4_1_Core.glTexCoordP2ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glTexCoordP2ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexCoordP2ui, doc_QOpenGLFunctions_4_1_Core_glTexCoordP2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glTexCoordP1ui, "QOpenGLFunctions_4_1_Core.glTexCoordP1ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP1ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glTexCoordP1ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glTexCoordP1ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glTexCoordP1ui, doc_QOpenGLFunctions_4_1_Core_glTexCoordP1ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexP4ui, "QOpenGLFunctions_4_1_Core.glVertexP4ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glVertexP4ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexP4ui, doc_QOpenGLFunctions_4_1_Core_glVertexP4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexP3ui, "QOpenGLFunctions_4_1_Core.glVertexP3ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glVertexP3ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexP3ui, doc_QOpenGLFunctions_4_1_Core_glVertexP3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexP2ui, "QOpenGLFunctions_4_1_Core.glVertexP2ui(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexP2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glVertexP2ui(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexP2ui, doc_QOpenGLFunctions_4_1_Core_glVertexP2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glQueryCounter, "QOpenGLFunctions_4_1_Core.glQueryCounter(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glQueryCounter(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glQueryCounter(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glQueryCounter(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glQueryCounter, doc_QOpenGLFunctions_4_1_Core_glQueryCounter);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glSamplerParameterf, "QOpenGLFunctions_4_1_Core.glSamplerParameterf(int, int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glSamplerParameterf(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glSamplerParameterf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLfloat a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glSamplerParameterf(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glSamplerParameterf, doc_QOpenGLFunctions_4_1_Core_glSamplerParameterf);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glSamplerParameteri, "QOpenGLFunctions_4_1_Core.glSamplerParameteri(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glSamplerParameteri(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glSamplerParameteri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glSamplerParameteri(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glSamplerParameteri, doc_QOpenGLFunctions_4_1_Core_glSamplerParameteri);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindSampler, "QOpenGLFunctions_4_1_Core.glBindSampler(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindSampler(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindSampler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindSampler(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindSampler, doc_QOpenGLFunctions_4_1_Core_glBindSampler);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsSampler, "QOpenGLFunctions_4_1_Core.glIsSampler(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsSampler(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsSampler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsSampler(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsSampler, doc_QOpenGLFunctions_4_1_Core_glIsSampler);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor, "QOpenGLFunctions_4_1_Core.glVertexAttribDivisor(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glVertexAttribDivisor(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribDivisor, doc_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glEndQueryIndexed, "QOpenGLFunctions_4_1_Core.glEndQueryIndexed(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndQueryIndexed(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glEndQueryIndexed(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glEndQueryIndexed(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glEndQueryIndexed, doc_QOpenGLFunctions_4_1_Core_glEndQueryIndexed);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed, "QOpenGLFunctions_4_1_Core.glBeginQueryIndexed(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glBeginQueryIndexed(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBeginQueryIndexed, doc_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream, "QOpenGLFunctions_4_1_Core.glDrawTransformFeedbackStream(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glDrawTransformFeedbackStream(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawTransformFeedbackStream, doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback, "QOpenGLFunctions_4_1_Core.glDrawTransformFeedback(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glDrawTransformFeedback(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDrawTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback, "QOpenGLFunctions_4_1_Core.glResumeTransformFeedback()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glResumeTransformFeedback();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glResumeTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback, "QOpenGLFunctions_4_1_Core.glPauseTransformFeedback()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glPauseTransformFeedback();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPauseTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsTransformFeedback, "QOpenGLFunctions_4_1_Core.glIsTransformFeedback(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsTransformFeedback(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glIsTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindTransformFeedback, "QOpenGLFunctions_4_1_Core.glBindTransformFeedback(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindTransformFeedback(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindTransformFeedback(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBindTransformFeedback(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindTransformFeedback, doc_QOpenGLFunctions_4_1_Core_glBindTransformFeedback);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glPatchParameteri, "QOpenGLFunctions_4_1_Core.glPatchParameteri(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glPatchParameteri(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glPatchParameteri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLenum a0;
        GLint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glPatchParameteri(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glPatchParameteri, doc_QOpenGLFunctions_4_1_Core_glPatchParameteri);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform4d, "QOpenGLFunctions_4_1_Core.glUniform4d(int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform4d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLdouble a1;
        GLdouble a2;
        GLdouble a3;
        GLdouble a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bidddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glUniform4d(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform4d, doc_QOpenGLFunctions_4_1_Core_glUniform4d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform3d, "QOpenGLFunctions_4_1_Core.glUniform3d(int, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform3d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLdouble a1;
        GLdouble a2;
        GLdouble a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glUniform3d(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform3d, doc_QOpenGLFunctions_4_1_Core_glUniform3d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform2d, "QOpenGLFunctions_4_1_Core.glUniform2d(int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform2d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLdouble a1;
        GLdouble a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bidd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUniform2d(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform2d, doc_QOpenGLFunctions_4_1_Core_glUniform2d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUniform1d, "QOpenGLFunctions_4_1_Core.glUniform1d(int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUniform1d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLint a0;
        GLdouble a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bid", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glUniform1d(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUniform1d, doc_QOpenGLFunctions_4_1_Core_glUniform1d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei, "QOpenGLFunctions_4_1_Core.glBlendFuncSeparatei(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLenum a2;
        GLenum a3;
        GLenum a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glBlendFuncSeparatei(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendFuncSeparatei, doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendFunci, "QOpenGLFunctions_4_1_Core.glBlendFunci(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFunci(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendFunci(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLenum a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glBlendFunci(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendFunci, doc_QOpenGLFunctions_4_1_Core_glBlendFunci);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei, "QOpenGLFunctions_4_1_Core.glBlendEquationSeparatei(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLenum a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glBlendEquationSeparatei(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendEquationSeparatei, doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBlendEquationi, "QOpenGLFunctions_4_1_Core.glBlendEquationi(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationi(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBlendEquationi(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glBlendEquationi(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBlendEquationi, doc_QOpenGLFunctions_4_1_Core_glBlendEquationi);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glMinSampleShading, "QOpenGLFunctions_4_1_Core.glMinSampleShading(float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glMinSampleShading(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glMinSampleShading(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glMinSampleShading(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glMinSampleShading, doc_QOpenGLFunctions_4_1_Core_glMinSampleShading);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed, "QOpenGLFunctions_4_1_Core.glDepthRangeIndexed(int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLdouble a1;
        GLdouble a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Budd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glDepthRangeIndexed(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDepthRangeIndexed, doc_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glScissorIndexed, "QOpenGLFunctions_4_1_Core.glScissorIndexed(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glScissorIndexed(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glScissorIndexed(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLint a2;
        GLsizei a3;
        GLsizei a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glScissorIndexed(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glScissorIndexed, doc_QOpenGLFunctions_4_1_Core_glScissorIndexed);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glViewportIndexedf, "QOpenGLFunctions_4_1_Core.glViewportIndexedf(int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glViewportIndexedf(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glViewportIndexedf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLfloat a1;
        GLfloat a2;
        GLfloat a3;
        GLfloat a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buffff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glViewportIndexedf(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glViewportIndexedf, doc_QOpenGLFunctions_4_1_Core_glViewportIndexedf);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL4d, "QOpenGLFunctions_4_1_Core.glVertexAttribL4d(int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL4d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL4d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLdouble a1;
        GLdouble a2;
        GLdouble a3;
        GLdouble a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Budddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glVertexAttribL4d(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribL4d, doc_QOpenGLFunctions_4_1_Core_glVertexAttribL4d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL3d, "QOpenGLFunctions_4_1_Core.glVertexAttribL3d(int, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL3d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL3d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLdouble a1;
        GLdouble a2;
        GLdouble a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glVertexAttribL3d(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribL3d, doc_QOpenGLFunctions_4_1_Core_glVertexAttribL3d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL2d, "QOpenGLFunctions_4_1_Core.glVertexAttribL2d(int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL2d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL2d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLdouble a1;
        GLdouble a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Budd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glVertexAttribL2d(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribL2d, doc_QOpenGLFunctions_4_1_Core_glVertexAttribL2d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL1d, "QOpenGLFunctions_4_1_Core.glVertexAttribL1d(int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL1d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glVertexAttribL1d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLdouble a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bud", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glVertexAttribL1d(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glVertexAttribL1d, doc_QOpenGLFunctions_4_1_Core_glVertexAttribL1d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline, "QOpenGLFunctions_4_1_Core.glValidateProgramPipeline(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glValidateProgramPipeline(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glValidateProgramPipeline, doc_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4ui, "QOpenGLFunctions_4_1_Core.glProgramUniform4ui(int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLuint a2;
        GLuint a3;
        GLuint a4;
        GLuint a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glProgramUniform4ui(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform4ui, doc_QOpenGLFunctions_4_1_Core_glProgramUniform4ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4d, "QOpenGLFunctions_4_1_Core.glProgramUniform4d(int, int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLdouble a2;
        GLdouble a3;
        GLdouble a4;
        GLdouble a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buidddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glProgramUniform4d(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform4d, doc_QOpenGLFunctions_4_1_Core_glProgramUniform4d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4f, "QOpenGLFunctions_4_1_Core.glProgramUniform4f(int, int, float, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLfloat a2;
        GLfloat a3;
        GLfloat a4;
        GLfloat a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiffff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glProgramUniform4f(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform4f, doc_QOpenGLFunctions_4_1_Core_glProgramUniform4f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4i, "QOpenGLFunctions_4_1_Core.glProgramUniform4i(int, int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform4i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        GLint a5;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4, &a5))
        {
            sipCpp->glProgramUniform4i(a0,a1,a2,a3,a4,a5);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform4i, doc_QOpenGLFunctions_4_1_Core_glProgramUniform4i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3ui, "QOpenGLFunctions_4_1_Core.glProgramUniform3ui(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLuint a2;
        GLuint a3;
        GLuint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glProgramUniform3ui(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform3ui, doc_QOpenGLFunctions_4_1_Core_glProgramUniform3ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3d, "QOpenGLFunctions_4_1_Core.glProgramUniform3d(int, int, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLdouble a2;
        GLdouble a3;
        GLdouble a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiddd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glProgramUniform3d(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform3d, doc_QOpenGLFunctions_4_1_Core_glProgramUniform3d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3f, "QOpenGLFunctions_4_1_Core.glProgramUniform3f(int, int, float, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLfloat a2;
        GLfloat a3;
        GLfloat a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buifff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glProgramUniform3f(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform3f, doc_QOpenGLFunctions_4_1_Core_glProgramUniform3f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3i, "QOpenGLFunctions_4_1_Core.glProgramUniform3i(int, int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform3i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        GLint a4;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            sipCpp->glProgramUniform3i(a0,a1,a2,a3,a4);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform3i, doc_QOpenGLFunctions_4_1_Core_glProgramUniform3i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2ui, "QOpenGLFunctions_4_1_Core.glProgramUniform2ui(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLuint a2;
        GLuint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glProgramUniform2ui(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform2ui, doc_QOpenGLFunctions_4_1_Core_glProgramUniform2ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2d, "QOpenGLFunctions_4_1_Core.glProgramUniform2d(int, int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLdouble a2;
        GLdouble a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buidd", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glProgramUniform2d(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform2d, doc_QOpenGLFunctions_4_1_Core_glProgramUniform2d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2f, "QOpenGLFunctions_4_1_Core.glProgramUniform2f(int, int, float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLfloat a2;
        GLfloat a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glProgramUniform2f(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform2f, doc_QOpenGLFunctions_4_1_Core_glProgramUniform2f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2i, "QOpenGLFunctions_4_1_Core.glProgramUniform2i(int, int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform2i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLint a2;
        GLint a3;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2, &a3))
        {
            sipCpp->glProgramUniform2i(a0,a1,a2,a3);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform2i, doc_QOpenGLFunctions_4_1_Core_glProgramUniform2i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1ui, "QOpenGLFunctions_4_1_Core.glProgramUniform1ui(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1ui(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1ui(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buiu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glProgramUniform1ui(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform1ui, doc_QOpenGLFunctions_4_1_Core_glProgramUniform1ui);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1d, "QOpenGLFunctions_4_1_Core.glProgramUniform1d(int, int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1d(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1d(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLdouble a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buid", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glProgramUniform1d(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform1d, doc_QOpenGLFunctions_4_1_Core_glProgramUniform1d);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1f, "QOpenGLFunctions_4_1_Core.glProgramUniform1f(int, int, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1f(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1f(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLfloat a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buif", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glProgramUniform1f(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform1f, doc_QOpenGLFunctions_4_1_Core_glProgramUniform1f);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1i, "QOpenGLFunctions_4_1_Core.glProgramUniform1i(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1i(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramUniform1i(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLint a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buii", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glProgramUniform1i(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramUniform1i, doc_QOpenGLFunctions_4_1_Core_glProgramUniform1i);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glIsProgramPipeline, "QOpenGLFunctions_4_1_Core.glIsProgramPipeline(int) -> int");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsProgramPipeline(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glIsProgramPipeline(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            GLboolean sipRes;

            sipRes = sipCpp->glIsProgramPipeline(a0);

#if PY_MAJOR_VERSION >= 3
            return PyLong_FromUnsignedLong(sipRes);
#else
            return PyInt_FromLong(sipRes);
#endif
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glIsProgramPipeline, doc_QOpenGLFunctions_4_1_Core_glIsProgramPipeline);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glBindProgramPipeline, "QOpenGLFunctions_4_1_Core.glBindProgramPipeline(int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindProgramPipeline(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glBindProgramPipeline(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glBindProgramPipeline(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glBindProgramPipeline, doc_QOpenGLFunctions_4_1_Core_glBindProgramPipeline);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glActiveShaderProgram, "QOpenGLFunctions_4_1_Core.glActiveShaderProgram(int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glActiveShaderProgram(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glActiveShaderProgram(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLuint a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glActiveShaderProgram(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glActiveShaderProgram, doc_QOpenGLFunctions_4_1_Core_glActiveShaderProgram);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glUseProgramStages, "QOpenGLFunctions_4_1_Core.glUseProgramStages(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glUseProgramStages(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glUseProgramStages(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLbitfield a1;
        GLuint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buuu", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glUseProgramStages(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glUseProgramStages, doc_QOpenGLFunctions_4_1_Core_glUseProgramStages);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glProgramParameteri, "QOpenGLFunctions_4_1_Core.glProgramParameteri(int, int, int)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramParameteri(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glProgramParameteri(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLuint a0;
        GLenum a1;
        GLint a2;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Buui", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1, &a2))
        {
            sipCpp->glProgramParameteri(a0,a1,a2);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glProgramParameteri, doc_QOpenGLFunctions_4_1_Core_glProgramParameteri);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glClearDepthf, "QOpenGLFunctions_4_1_Core.glClearDepthf(float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearDepthf(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glClearDepthf(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bf", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0))
        {
            sipCpp->glClearDepthf(a0);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glClearDepthf, doc_QOpenGLFunctions_4_1_Core_glClearDepthf);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glDepthRangef, "QOpenGLFunctions_4_1_Core.glDepthRangef(float, float)");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRangef(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glDepthRangef(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        GLfloat a0;
        GLfloat a1;
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bff", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp, &a0, &a1))
        {
            sipCpp->glDepthRangef(a0,a1);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glDepthRangef, doc_QOpenGLFunctions_4_1_Core_glDepthRangef);

    return NULL;
}


PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler, "QOpenGLFunctions_4_1_Core.glReleaseShaderCompiler()");

extern "C" {static PyObject *meth_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler(PyObject *, PyObject *);}
static PyObject *meth_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        QOpenGLFunctions_4_1_Core *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QOpenGLFunctions_4_1_Core, &sipCpp))
        {
            sipCpp->glReleaseShaderCompiler();

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QOpenGLFunctions_4_1_Core, sipName_glReleaseShaderCompiler, doc_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler);

    return NULL;
}


/* Cast a pointer to a type somewhere in its superclass hierarchy. */
extern "C" {static void *cast_QOpenGLFunctions_4_1_Core(void *, const sipTypeDef *);}
static void *cast_QOpenGLFunctions_4_1_Core(void *ptr, const sipTypeDef *targetType)
{
    void *res;

    if (targetType == sipType_QOpenGLFunctions_4_1_Core)
        return ptr;

    if ((res = ((const sipClassTypeDef *)sipType_QAbstractOpenGLFunctions)->ctd_cast((QAbstractOpenGLFunctions *)(QOpenGLFunctions_4_1_Core *)ptr,targetType)) != NULL)
        return res;

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QOpenGLFunctions_4_1_Core(void *, int);}
static void release_QOpenGLFunctions_4_1_Core(void *sipCppV,int sipState)
{
    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQOpenGLFunctions_4_1_Core *>(sipCppV);
    else
        delete reinterpret_cast<QOpenGLFunctions_4_1_Core *>(sipCppV);
}


extern "C" {static void dealloc_QOpenGLFunctions_4_1_Core(sipSimpleWrapper *);}
static void dealloc_QOpenGLFunctions_4_1_Core(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerived(sipSelf))
        reinterpret_cast<sipQOpenGLFunctions_4_1_Core *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsPyOwned(sipSelf))
    {
        release_QOpenGLFunctions_4_1_Core(sipGetAddress(sipSelf),sipSelf->flags);
    }
}


extern "C" {static void *init_type_QOpenGLFunctions_4_1_Core(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QOpenGLFunctions_4_1_Core(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQOpenGLFunctions_4_1_Core *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            sipCpp = new sipQOpenGLFunctions_4_1_Core();

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QOpenGLFunctions_4_1_Core[] = {{0, 1, 1}};


static PyMethodDef methods_QOpenGLFunctions_4_1_Core[] = {
    {SIP_MLNAME_CAST(sipName_glActiveShaderProgram), meth_QOpenGLFunctions_4_1_Core_glActiveShaderProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glActiveShaderProgram)},
    {SIP_MLNAME_CAST(sipName_glActiveTexture), meth_QOpenGLFunctions_4_1_Core_glActiveTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glActiveTexture)},
    {SIP_MLNAME_CAST(sipName_glAttachShader), meth_QOpenGLFunctions_4_1_Core_glAttachShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glAttachShader)},
    {SIP_MLNAME_CAST(sipName_glBeginConditionalRender), meth_QOpenGLFunctions_4_1_Core_glBeginConditionalRender, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBeginConditionalRender)},
    {SIP_MLNAME_CAST(sipName_glBeginQuery), meth_QOpenGLFunctions_4_1_Core_glBeginQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBeginQuery)},
    {SIP_MLNAME_CAST(sipName_glBeginQueryIndexed), meth_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBeginQueryIndexed)},
    {SIP_MLNAME_CAST(sipName_glBeginTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBeginTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glBindAttribLocation), meth_QOpenGLFunctions_4_1_Core_glBindAttribLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindAttribLocation)},
    {SIP_MLNAME_CAST(sipName_glBindBuffer), meth_QOpenGLFunctions_4_1_Core_glBindBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindBuffer)},
    {SIP_MLNAME_CAST(sipName_glBindBufferBase), meth_QOpenGLFunctions_4_1_Core_glBindBufferBase, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindBufferBase)},
    {SIP_MLNAME_CAST(sipName_glBindFramebuffer), meth_QOpenGLFunctions_4_1_Core_glBindFramebuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindFramebuffer)},
    {SIP_MLNAME_CAST(sipName_glBindProgramPipeline), meth_QOpenGLFunctions_4_1_Core_glBindProgramPipeline, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindProgramPipeline)},
    {SIP_MLNAME_CAST(sipName_glBindRenderbuffer), meth_QOpenGLFunctions_4_1_Core_glBindRenderbuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindRenderbuffer)},
    {SIP_MLNAME_CAST(sipName_glBindSampler), meth_QOpenGLFunctions_4_1_Core_glBindSampler, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindSampler)},
    {SIP_MLNAME_CAST(sipName_glBindTexture), meth_QOpenGLFunctions_4_1_Core_glBindTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindTexture)},
    {SIP_MLNAME_CAST(sipName_glBindTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glBindTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glBindVertexArray), meth_QOpenGLFunctions_4_1_Core_glBindVertexArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBindVertexArray)},
    {SIP_MLNAME_CAST(sipName_glBlendColor), meth_QOpenGLFunctions_4_1_Core_glBlendColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendColor)},
    {SIP_MLNAME_CAST(sipName_glBlendEquation), meth_QOpenGLFunctions_4_1_Core_glBlendEquation, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendEquation)},
    {SIP_MLNAME_CAST(sipName_glBlendEquationSeparate), meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparate)},
    {SIP_MLNAME_CAST(sipName_glBlendEquationSeparatei), meth_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendEquationSeparatei)},
    {SIP_MLNAME_CAST(sipName_glBlendEquationi), meth_QOpenGLFunctions_4_1_Core_glBlendEquationi, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendEquationi)},
    {SIP_MLNAME_CAST(sipName_glBlendFunc), meth_QOpenGLFunctions_4_1_Core_glBlendFunc, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendFunc)},
    {SIP_MLNAME_CAST(sipName_glBlendFuncSeparate), meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparate)},
    {SIP_MLNAME_CAST(sipName_glBlendFuncSeparatei), meth_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendFuncSeparatei)},
    {SIP_MLNAME_CAST(sipName_glBlendFunci), meth_QOpenGLFunctions_4_1_Core_glBlendFunci, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlendFunci)},
    {SIP_MLNAME_CAST(sipName_glBlitFramebuffer), meth_QOpenGLFunctions_4_1_Core_glBlitFramebuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBlitFramebuffer)},
    {SIP_MLNAME_CAST(sipName_glBufferData), meth_QOpenGLFunctions_4_1_Core_glBufferData, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBufferData)},
    {SIP_MLNAME_CAST(sipName_glBufferSubData), meth_QOpenGLFunctions_4_1_Core_glBufferSubData, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glBufferSubData)},
    {SIP_MLNAME_CAST(sipName_glCheckFramebufferStatus), meth_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCheckFramebufferStatus)},
    {SIP_MLNAME_CAST(sipName_glClampColor), meth_QOpenGLFunctions_4_1_Core_glClampColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClampColor)},
    {SIP_MLNAME_CAST(sipName_glClear), meth_QOpenGLFunctions_4_1_Core_glClear, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClear)},
    {SIP_MLNAME_CAST(sipName_glClearBufferfi), meth_QOpenGLFunctions_4_1_Core_glClearBufferfi, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClearBufferfi)},
    {SIP_MLNAME_CAST(sipName_glClearColor), meth_QOpenGLFunctions_4_1_Core_glClearColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClearColor)},
    {SIP_MLNAME_CAST(sipName_glClearDepth), meth_QOpenGLFunctions_4_1_Core_glClearDepth, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClearDepth)},
    {SIP_MLNAME_CAST(sipName_glClearDepthf), meth_QOpenGLFunctions_4_1_Core_glClearDepthf, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClearDepthf)},
    {SIP_MLNAME_CAST(sipName_glClearStencil), meth_QOpenGLFunctions_4_1_Core_glClearStencil, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glClearStencil)},
    {SIP_MLNAME_CAST(sipName_glColorMask), meth_QOpenGLFunctions_4_1_Core_glColorMask, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glColorMask)},
    {SIP_MLNAME_CAST(sipName_glColorMaski), meth_QOpenGLFunctions_4_1_Core_glColorMaski, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glColorMaski)},
    {SIP_MLNAME_CAST(sipName_glColorP3ui), meth_QOpenGLFunctions_4_1_Core_glColorP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glColorP3ui)},
    {SIP_MLNAME_CAST(sipName_glColorP4ui), meth_QOpenGLFunctions_4_1_Core_glColorP4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glColorP4ui)},
    {SIP_MLNAME_CAST(sipName_glCompileShader), meth_QOpenGLFunctions_4_1_Core_glCompileShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompileShader)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexImage1D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage1D)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexImage2D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage2D)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexImage3D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexImage3D)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexSubImage1D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage1D)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexSubImage2D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage2D)},
    {SIP_MLNAME_CAST(sipName_glCompressedTexSubImage3D), meth_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCompressedTexSubImage3D)},
    {SIP_MLNAME_CAST(sipName_glCopyTexImage1D), meth_QOpenGLFunctions_4_1_Core_glCopyTexImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCopyTexImage1D)},
    {SIP_MLNAME_CAST(sipName_glCopyTexImage2D), meth_QOpenGLFunctions_4_1_Core_glCopyTexImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCopyTexImage2D)},
    {SIP_MLNAME_CAST(sipName_glCopyTexSubImage1D), meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage1D)},
    {SIP_MLNAME_CAST(sipName_glCopyTexSubImage2D), meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage2D)},
    {SIP_MLNAME_CAST(sipName_glCopyTexSubImage3D), meth_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCopyTexSubImage3D)},
    {SIP_MLNAME_CAST(sipName_glCreateProgram), meth_QOpenGLFunctions_4_1_Core_glCreateProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCreateProgram)},
    {SIP_MLNAME_CAST(sipName_glCreateShader), meth_QOpenGLFunctions_4_1_Core_glCreateShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCreateShader)},
    {SIP_MLNAME_CAST(sipName_glCullFace), meth_QOpenGLFunctions_4_1_Core_glCullFace, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glCullFace)},
    {SIP_MLNAME_CAST(sipName_glDeleteBuffers), meth_QOpenGLFunctions_4_1_Core_glDeleteBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDeleteBuffers)},
    {SIP_MLNAME_CAST(sipName_glDeleteProgram), meth_QOpenGLFunctions_4_1_Core_glDeleteProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDeleteProgram)},
    {SIP_MLNAME_CAST(sipName_glDeleteQueries), meth_QOpenGLFunctions_4_1_Core_glDeleteQueries, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDeleteQueries)},
    {SIP_MLNAME_CAST(sipName_glDeleteShader), meth_QOpenGLFunctions_4_1_Core_glDeleteShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDeleteShader)},
    {SIP_MLNAME_CAST(sipName_glDeleteTextures), meth_QOpenGLFunctions_4_1_Core_glDeleteTextures, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDeleteTextures)},
    {SIP_MLNAME_CAST(sipName_glDepthFunc), meth_QOpenGLFunctions_4_1_Core_glDepthFunc, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDepthFunc)},
    {SIP_MLNAME_CAST(sipName_glDepthMask), meth_QOpenGLFunctions_4_1_Core_glDepthMask, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDepthMask)},
    {SIP_MLNAME_CAST(sipName_glDepthRange), meth_QOpenGLFunctions_4_1_Core_glDepthRange, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDepthRange)},
    {SIP_MLNAME_CAST(sipName_glDepthRangeIndexed), meth_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDepthRangeIndexed)},
    {SIP_MLNAME_CAST(sipName_glDepthRangef), meth_QOpenGLFunctions_4_1_Core_glDepthRangef, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDepthRangef)},
    {SIP_MLNAME_CAST(sipName_glDetachShader), meth_QOpenGLFunctions_4_1_Core_glDetachShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDetachShader)},
    {SIP_MLNAME_CAST(sipName_glDisable), meth_QOpenGLFunctions_4_1_Core_glDisable, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDisable)},
    {SIP_MLNAME_CAST(sipName_glDisableVertexAttribArray), meth_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDisableVertexAttribArray)},
    {SIP_MLNAME_CAST(sipName_glDisablei), meth_QOpenGLFunctions_4_1_Core_glDisablei, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDisablei)},
    {SIP_MLNAME_CAST(sipName_glDrawArrays), meth_QOpenGLFunctions_4_1_Core_glDrawArrays, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawArrays)},
    {SIP_MLNAME_CAST(sipName_glDrawArraysInstanced), meth_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawArraysInstanced)},
    {SIP_MLNAME_CAST(sipName_glDrawBuffer), meth_QOpenGLFunctions_4_1_Core_glDrawBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawBuffer)},
    {SIP_MLNAME_CAST(sipName_glDrawBuffers), meth_QOpenGLFunctions_4_1_Core_glDrawBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawBuffers)},
    {SIP_MLNAME_CAST(sipName_glDrawElements), meth_QOpenGLFunctions_4_1_Core_glDrawElements, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawElements)},
    {SIP_MLNAME_CAST(sipName_glDrawRangeElements), meth_QOpenGLFunctions_4_1_Core_glDrawRangeElements, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawRangeElements)},
    {SIP_MLNAME_CAST(sipName_glDrawTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glDrawTransformFeedbackStream), meth_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glDrawTransformFeedbackStream)},
    {SIP_MLNAME_CAST(sipName_glEnable), meth_QOpenGLFunctions_4_1_Core_glEnable, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEnable)},
    {SIP_MLNAME_CAST(sipName_glEnableVertexAttribArray), meth_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEnableVertexAttribArray)},
    {SIP_MLNAME_CAST(sipName_glEnablei), meth_QOpenGLFunctions_4_1_Core_glEnablei, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEnablei)},
    {SIP_MLNAME_CAST(sipName_glEndConditionalRender), meth_QOpenGLFunctions_4_1_Core_glEndConditionalRender, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEndConditionalRender)},
    {SIP_MLNAME_CAST(sipName_glEndQuery), meth_QOpenGLFunctions_4_1_Core_glEndQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEndQuery)},
    {SIP_MLNAME_CAST(sipName_glEndQueryIndexed), meth_QOpenGLFunctions_4_1_Core_glEndQueryIndexed, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEndQueryIndexed)},
    {SIP_MLNAME_CAST(sipName_glEndTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glEndTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glEndTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glFinish), meth_QOpenGLFunctions_4_1_Core_glFinish, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFinish)},
    {SIP_MLNAME_CAST(sipName_glFlush), meth_QOpenGLFunctions_4_1_Core_glFlush, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFlush)},
    {SIP_MLNAME_CAST(sipName_glFramebufferRenderbuffer), meth_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferRenderbuffer)},
    {SIP_MLNAME_CAST(sipName_glFramebufferTexture), meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture)},
    {SIP_MLNAME_CAST(sipName_glFramebufferTexture1D), meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture1D)},
    {SIP_MLNAME_CAST(sipName_glFramebufferTexture2D), meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture2D)},
    {SIP_MLNAME_CAST(sipName_glFramebufferTexture3D), meth_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferTexture3D)},
    {SIP_MLNAME_CAST(sipName_glFramebufferTextureLayer), meth_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFramebufferTextureLayer)},
    {SIP_MLNAME_CAST(sipName_glFrontFace), meth_QOpenGLFunctions_4_1_Core_glFrontFace, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glFrontFace)},
    {SIP_MLNAME_CAST(sipName_glGenBuffers), meth_QOpenGLFunctions_4_1_Core_glGenBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGenBuffers)},
    {SIP_MLNAME_CAST(sipName_glGenQueries), meth_QOpenGLFunctions_4_1_Core_glGenQueries, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGenQueries)},
    {SIP_MLNAME_CAST(sipName_glGenTextures), meth_QOpenGLFunctions_4_1_Core_glGenTextures, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGenTextures)},
    {SIP_MLNAME_CAST(sipName_glGenerateMipmap), meth_QOpenGLFunctions_4_1_Core_glGenerateMipmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGenerateMipmap)},
    {SIP_MLNAME_CAST(sipName_glGetActiveAttrib), meth_QOpenGLFunctions_4_1_Core_glGetActiveAttrib, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetActiveAttrib)},
    {SIP_MLNAME_CAST(sipName_glGetActiveUniform), meth_QOpenGLFunctions_4_1_Core_glGetActiveUniform, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetActiveUniform)},
    {SIP_MLNAME_CAST(sipName_glGetAttachedShaders), meth_QOpenGLFunctions_4_1_Core_glGetAttachedShaders, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetAttachedShaders)},
    {SIP_MLNAME_CAST(sipName_glGetAttribLocation), meth_QOpenGLFunctions_4_1_Core_glGetAttribLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetAttribLocation)},
    {SIP_MLNAME_CAST(sipName_glGetBooleanv), meth_QOpenGLFunctions_4_1_Core_glGetBooleanv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetBooleanv)},
    {SIP_MLNAME_CAST(sipName_glGetBufferParameteriv), meth_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetBufferParameteriv)},
    {SIP_MLNAME_CAST(sipName_glGetDoublev), meth_QOpenGLFunctions_4_1_Core_glGetDoublev, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetDoublev)},
    {SIP_MLNAME_CAST(sipName_glGetError), meth_QOpenGLFunctions_4_1_Core_glGetError, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetError)},
    {SIP_MLNAME_CAST(sipName_glGetFloatv), meth_QOpenGLFunctions_4_1_Core_glGetFloatv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetFloatv)},
    {SIP_MLNAME_CAST(sipName_glGetIntegerv), meth_QOpenGLFunctions_4_1_Core_glGetIntegerv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetIntegerv)},
    {SIP_MLNAME_CAST(sipName_glGetProgramInfoLog), meth_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetProgramInfoLog)},
    {SIP_MLNAME_CAST(sipName_glGetProgramiv), meth_QOpenGLFunctions_4_1_Core_glGetProgramiv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetProgramiv)},
    {SIP_MLNAME_CAST(sipName_glGetQueryiv), meth_QOpenGLFunctions_4_1_Core_glGetQueryiv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetQueryiv)},
    {SIP_MLNAME_CAST(sipName_glGetShaderInfoLog), meth_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetShaderInfoLog)},
    {SIP_MLNAME_CAST(sipName_glGetShaderSource), meth_QOpenGLFunctions_4_1_Core_glGetShaderSource, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetShaderSource)},
    {SIP_MLNAME_CAST(sipName_glGetShaderiv), meth_QOpenGLFunctions_4_1_Core_glGetShaderiv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetShaderiv)},
    {SIP_MLNAME_CAST(sipName_glGetString), meth_QOpenGLFunctions_4_1_Core_glGetString, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetString)},
    {SIP_MLNAME_CAST(sipName_glGetTexLevelParameterfv), meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameterfv)},
    {SIP_MLNAME_CAST(sipName_glGetTexLevelParameteriv), meth_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetTexLevelParameteriv)},
    {SIP_MLNAME_CAST(sipName_glGetTexParameterfv), meth_QOpenGLFunctions_4_1_Core_glGetTexParameterfv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetTexParameterfv)},
    {SIP_MLNAME_CAST(sipName_glGetTexParameteriv), meth_QOpenGLFunctions_4_1_Core_glGetTexParameteriv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetTexParameteriv)},
    {SIP_MLNAME_CAST(sipName_glGetUniformLocation), meth_QOpenGLFunctions_4_1_Core_glGetUniformLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetUniformLocation)},
    {SIP_MLNAME_CAST(sipName_glGetVertexAttribdv), meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribdv)},
    {SIP_MLNAME_CAST(sipName_glGetVertexAttribfv), meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribfv)},
    {SIP_MLNAME_CAST(sipName_glGetVertexAttribiv), meth_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glGetVertexAttribiv)},
    {SIP_MLNAME_CAST(sipName_glHint), meth_QOpenGLFunctions_4_1_Core_glHint, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glHint)},
    {SIP_MLNAME_CAST(sipName_glIndexub), meth_QOpenGLFunctions_4_1_Core_glIndexub, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIndexub)},
    {SIP_MLNAME_CAST(sipName_glIndexubv), meth_QOpenGLFunctions_4_1_Core_glIndexubv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIndexubv)},
    {SIP_MLNAME_CAST(sipName_glIsBuffer), meth_QOpenGLFunctions_4_1_Core_glIsBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsBuffer)},
    {SIP_MLNAME_CAST(sipName_glIsEnabled), meth_QOpenGLFunctions_4_1_Core_glIsEnabled, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsEnabled)},
    {SIP_MLNAME_CAST(sipName_glIsEnabledi), meth_QOpenGLFunctions_4_1_Core_glIsEnabledi, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsEnabledi)},
    {SIP_MLNAME_CAST(sipName_glIsFramebuffer), meth_QOpenGLFunctions_4_1_Core_glIsFramebuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsFramebuffer)},
    {SIP_MLNAME_CAST(sipName_glIsProgram), meth_QOpenGLFunctions_4_1_Core_glIsProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsProgram)},
    {SIP_MLNAME_CAST(sipName_glIsProgramPipeline), meth_QOpenGLFunctions_4_1_Core_glIsProgramPipeline, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsProgramPipeline)},
    {SIP_MLNAME_CAST(sipName_glIsQuery), meth_QOpenGLFunctions_4_1_Core_glIsQuery, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsQuery)},
    {SIP_MLNAME_CAST(sipName_glIsRenderbuffer), meth_QOpenGLFunctions_4_1_Core_glIsRenderbuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsRenderbuffer)},
    {SIP_MLNAME_CAST(sipName_glIsSampler), meth_QOpenGLFunctions_4_1_Core_glIsSampler, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsSampler)},
    {SIP_MLNAME_CAST(sipName_glIsShader), meth_QOpenGLFunctions_4_1_Core_glIsShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsShader)},
    {SIP_MLNAME_CAST(sipName_glIsTexture), meth_QOpenGLFunctions_4_1_Core_glIsTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsTexture)},
    {SIP_MLNAME_CAST(sipName_glIsTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glIsTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glIsVertexArray), meth_QOpenGLFunctions_4_1_Core_glIsVertexArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glIsVertexArray)},
    {SIP_MLNAME_CAST(sipName_glLineWidth), meth_QOpenGLFunctions_4_1_Core_glLineWidth, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glLineWidth)},
    {SIP_MLNAME_CAST(sipName_glLinkProgram), meth_QOpenGLFunctions_4_1_Core_glLinkProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glLinkProgram)},
    {SIP_MLNAME_CAST(sipName_glLogicOp), meth_QOpenGLFunctions_4_1_Core_glLogicOp, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glLogicOp)},
    {SIP_MLNAME_CAST(sipName_glMinSampleShading), meth_QOpenGLFunctions_4_1_Core_glMinSampleShading, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glMinSampleShading)},
    {SIP_MLNAME_CAST(sipName_glMultiTexCoordP1ui), meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP1ui)},
    {SIP_MLNAME_CAST(sipName_glMultiTexCoordP2ui), meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP2ui)},
    {SIP_MLNAME_CAST(sipName_glMultiTexCoordP3ui), meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP3ui)},
    {SIP_MLNAME_CAST(sipName_glMultiTexCoordP4ui), meth_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glMultiTexCoordP4ui)},
    {SIP_MLNAME_CAST(sipName_glNormalP3ui), meth_QOpenGLFunctions_4_1_Core_glNormalP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glNormalP3ui)},
    {SIP_MLNAME_CAST(sipName_glPatchParameteri), meth_QOpenGLFunctions_4_1_Core_glPatchParameteri, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPatchParameteri)},
    {SIP_MLNAME_CAST(sipName_glPauseTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPauseTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glPixelStoref), meth_QOpenGLFunctions_4_1_Core_glPixelStoref, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPixelStoref)},
    {SIP_MLNAME_CAST(sipName_glPixelStorei), meth_QOpenGLFunctions_4_1_Core_glPixelStorei, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPixelStorei)},
    {SIP_MLNAME_CAST(sipName_glPointParameterf), meth_QOpenGLFunctions_4_1_Core_glPointParameterf, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPointParameterf)},
    {SIP_MLNAME_CAST(sipName_glPointParameterfv), meth_QOpenGLFunctions_4_1_Core_glPointParameterfv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPointParameterfv)},
    {SIP_MLNAME_CAST(sipName_glPointParameteri), meth_QOpenGLFunctions_4_1_Core_glPointParameteri, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPointParameteri)},
    {SIP_MLNAME_CAST(sipName_glPointParameteriv), meth_QOpenGLFunctions_4_1_Core_glPointParameteriv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPointParameteriv)},
    {SIP_MLNAME_CAST(sipName_glPointSize), meth_QOpenGLFunctions_4_1_Core_glPointSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPointSize)},
    {SIP_MLNAME_CAST(sipName_glPolygonMode), meth_QOpenGLFunctions_4_1_Core_glPolygonMode, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPolygonMode)},
    {SIP_MLNAME_CAST(sipName_glPolygonOffset), meth_QOpenGLFunctions_4_1_Core_glPolygonOffset, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPolygonOffset)},
    {SIP_MLNAME_CAST(sipName_glPrimitiveRestartIndex), meth_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glPrimitiveRestartIndex)},
    {SIP_MLNAME_CAST(sipName_glProgramParameteri), meth_QOpenGLFunctions_4_1_Core_glProgramParameteri, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramParameteri)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform1d), meth_QOpenGLFunctions_4_1_Core_glProgramUniform1d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1d)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform1f), meth_QOpenGLFunctions_4_1_Core_glProgramUniform1f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1f)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform1i), meth_QOpenGLFunctions_4_1_Core_glProgramUniform1i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1i)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform1ui), meth_QOpenGLFunctions_4_1_Core_glProgramUniform1ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform1ui)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform2d), meth_QOpenGLFunctions_4_1_Core_glProgramUniform2d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2d)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform2f), meth_QOpenGLFunctions_4_1_Core_glProgramUniform2f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2f)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform2i), meth_QOpenGLFunctions_4_1_Core_glProgramUniform2i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2i)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform2ui), meth_QOpenGLFunctions_4_1_Core_glProgramUniform2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform2ui)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform3d), meth_QOpenGLFunctions_4_1_Core_glProgramUniform3d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3d)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform3f), meth_QOpenGLFunctions_4_1_Core_glProgramUniform3f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3f)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform3i), meth_QOpenGLFunctions_4_1_Core_glProgramUniform3i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3i)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform3ui), meth_QOpenGLFunctions_4_1_Core_glProgramUniform3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform3ui)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform4d), meth_QOpenGLFunctions_4_1_Core_glProgramUniform4d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4d)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform4f), meth_QOpenGLFunctions_4_1_Core_glProgramUniform4f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4f)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform4i), meth_QOpenGLFunctions_4_1_Core_glProgramUniform4i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4i)},
    {SIP_MLNAME_CAST(sipName_glProgramUniform4ui), meth_QOpenGLFunctions_4_1_Core_glProgramUniform4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProgramUniform4ui)},
    {SIP_MLNAME_CAST(sipName_glProvokingVertex), meth_QOpenGLFunctions_4_1_Core_glProvokingVertex, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glProvokingVertex)},
    {SIP_MLNAME_CAST(sipName_glQueryCounter), meth_QOpenGLFunctions_4_1_Core_glQueryCounter, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glQueryCounter)},
    {SIP_MLNAME_CAST(sipName_glReadBuffer), meth_QOpenGLFunctions_4_1_Core_glReadBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glReadBuffer)},
    {SIP_MLNAME_CAST(sipName_glReleaseShaderCompiler), meth_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glReleaseShaderCompiler)},
    {SIP_MLNAME_CAST(sipName_glRenderbufferStorage), meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorage, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorage)},
    {SIP_MLNAME_CAST(sipName_glRenderbufferStorageMultisample), meth_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glRenderbufferStorageMultisample)},
    {SIP_MLNAME_CAST(sipName_glResumeTransformFeedback), meth_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glResumeTransformFeedback)},
    {SIP_MLNAME_CAST(sipName_glSampleCoverage), meth_QOpenGLFunctions_4_1_Core_glSampleCoverage, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glSampleCoverage)},
    {SIP_MLNAME_CAST(sipName_glSampleMaski), meth_QOpenGLFunctions_4_1_Core_glSampleMaski, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glSampleMaski)},
    {SIP_MLNAME_CAST(sipName_glSamplerParameterf), meth_QOpenGLFunctions_4_1_Core_glSamplerParameterf, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glSamplerParameterf)},
    {SIP_MLNAME_CAST(sipName_glSamplerParameteri), meth_QOpenGLFunctions_4_1_Core_glSamplerParameteri, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glSamplerParameteri)},
    {SIP_MLNAME_CAST(sipName_glScissor), meth_QOpenGLFunctions_4_1_Core_glScissor, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glScissor)},
    {SIP_MLNAME_CAST(sipName_glScissorIndexed), meth_QOpenGLFunctions_4_1_Core_glScissorIndexed, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glScissorIndexed)},
    {SIP_MLNAME_CAST(sipName_glSecondaryColorP3ui), meth_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glSecondaryColorP3ui)},
    {SIP_MLNAME_CAST(sipName_glStencilFunc), meth_QOpenGLFunctions_4_1_Core_glStencilFunc, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilFunc)},
    {SIP_MLNAME_CAST(sipName_glStencilFuncSeparate), meth_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilFuncSeparate)},
    {SIP_MLNAME_CAST(sipName_glStencilMask), meth_QOpenGLFunctions_4_1_Core_glStencilMask, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilMask)},
    {SIP_MLNAME_CAST(sipName_glStencilMaskSeparate), meth_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilMaskSeparate)},
    {SIP_MLNAME_CAST(sipName_glStencilOp), meth_QOpenGLFunctions_4_1_Core_glStencilOp, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilOp)},
    {SIP_MLNAME_CAST(sipName_glStencilOpSeparate), meth_QOpenGLFunctions_4_1_Core_glStencilOpSeparate, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glStencilOpSeparate)},
    {SIP_MLNAME_CAST(sipName_glTexBuffer), meth_QOpenGLFunctions_4_1_Core_glTexBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexBuffer)},
    {SIP_MLNAME_CAST(sipName_glTexCoordP1ui), meth_QOpenGLFunctions_4_1_Core_glTexCoordP1ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexCoordP1ui)},
    {SIP_MLNAME_CAST(sipName_glTexCoordP2ui), meth_QOpenGLFunctions_4_1_Core_glTexCoordP2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexCoordP2ui)},
    {SIP_MLNAME_CAST(sipName_glTexCoordP3ui), meth_QOpenGLFunctions_4_1_Core_glTexCoordP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexCoordP3ui)},
    {SIP_MLNAME_CAST(sipName_glTexCoordP4ui), meth_QOpenGLFunctions_4_1_Core_glTexCoordP4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexCoordP4ui)},
    {SIP_MLNAME_CAST(sipName_glTexImage1D), meth_QOpenGLFunctions_4_1_Core_glTexImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexImage1D)},
    {SIP_MLNAME_CAST(sipName_glTexImage2D), meth_QOpenGLFunctions_4_1_Core_glTexImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexImage2D)},
    {SIP_MLNAME_CAST(sipName_glTexImage2DMultisample), meth_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexImage2DMultisample)},
    {SIP_MLNAME_CAST(sipName_glTexImage3D), meth_QOpenGLFunctions_4_1_Core_glTexImage3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexImage3D)},
    {SIP_MLNAME_CAST(sipName_glTexImage3DMultisample), meth_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexImage3DMultisample)},
    {SIP_MLNAME_CAST(sipName_glTexParameterf), meth_QOpenGLFunctions_4_1_Core_glTexParameterf, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexParameterf)},
    {SIP_MLNAME_CAST(sipName_glTexParameterfv), meth_QOpenGLFunctions_4_1_Core_glTexParameterfv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexParameterfv)},
    {SIP_MLNAME_CAST(sipName_glTexParameteri), meth_QOpenGLFunctions_4_1_Core_glTexParameteri, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexParameteri)},
    {SIP_MLNAME_CAST(sipName_glTexParameteriv), meth_QOpenGLFunctions_4_1_Core_glTexParameteriv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexParameteriv)},
    {SIP_MLNAME_CAST(sipName_glTexSubImage1D), meth_QOpenGLFunctions_4_1_Core_glTexSubImage1D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexSubImage1D)},
    {SIP_MLNAME_CAST(sipName_glTexSubImage2D), meth_QOpenGLFunctions_4_1_Core_glTexSubImage2D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexSubImage2D)},
    {SIP_MLNAME_CAST(sipName_glTexSubImage3D), meth_QOpenGLFunctions_4_1_Core_glTexSubImage3D, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glTexSubImage3D)},
    {SIP_MLNAME_CAST(sipName_glUniform1d), meth_QOpenGLFunctions_4_1_Core_glUniform1d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1d)},
    {SIP_MLNAME_CAST(sipName_glUniform1f), meth_QOpenGLFunctions_4_1_Core_glUniform1f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1f)},
    {SIP_MLNAME_CAST(sipName_glUniform1fv), meth_QOpenGLFunctions_4_1_Core_glUniform1fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1fv)},
    {SIP_MLNAME_CAST(sipName_glUniform1i), meth_QOpenGLFunctions_4_1_Core_glUniform1i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1i)},
    {SIP_MLNAME_CAST(sipName_glUniform1iv), meth_QOpenGLFunctions_4_1_Core_glUniform1iv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1iv)},
    {SIP_MLNAME_CAST(sipName_glUniform1ui), meth_QOpenGLFunctions_4_1_Core_glUniform1ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform1ui)},
    {SIP_MLNAME_CAST(sipName_glUniform2d), meth_QOpenGLFunctions_4_1_Core_glUniform2d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2d)},
    {SIP_MLNAME_CAST(sipName_glUniform2f), meth_QOpenGLFunctions_4_1_Core_glUniform2f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2f)},
    {SIP_MLNAME_CAST(sipName_glUniform2fv), meth_QOpenGLFunctions_4_1_Core_glUniform2fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2fv)},
    {SIP_MLNAME_CAST(sipName_glUniform2i), meth_QOpenGLFunctions_4_1_Core_glUniform2i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2i)},
    {SIP_MLNAME_CAST(sipName_glUniform2iv), meth_QOpenGLFunctions_4_1_Core_glUniform2iv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2iv)},
    {SIP_MLNAME_CAST(sipName_glUniform2ui), meth_QOpenGLFunctions_4_1_Core_glUniform2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform2ui)},
    {SIP_MLNAME_CAST(sipName_glUniform3d), meth_QOpenGLFunctions_4_1_Core_glUniform3d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3d)},
    {SIP_MLNAME_CAST(sipName_glUniform3f), meth_QOpenGLFunctions_4_1_Core_glUniform3f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3f)},
    {SIP_MLNAME_CAST(sipName_glUniform3fv), meth_QOpenGLFunctions_4_1_Core_glUniform3fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3fv)},
    {SIP_MLNAME_CAST(sipName_glUniform3i), meth_QOpenGLFunctions_4_1_Core_glUniform3i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3i)},
    {SIP_MLNAME_CAST(sipName_glUniform3iv), meth_QOpenGLFunctions_4_1_Core_glUniform3iv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3iv)},
    {SIP_MLNAME_CAST(sipName_glUniform3ui), meth_QOpenGLFunctions_4_1_Core_glUniform3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform3ui)},
    {SIP_MLNAME_CAST(sipName_glUniform4d), meth_QOpenGLFunctions_4_1_Core_glUniform4d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4d)},
    {SIP_MLNAME_CAST(sipName_glUniform4f), meth_QOpenGLFunctions_4_1_Core_glUniform4f, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4f)},
    {SIP_MLNAME_CAST(sipName_glUniform4fv), meth_QOpenGLFunctions_4_1_Core_glUniform4fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4fv)},
    {SIP_MLNAME_CAST(sipName_glUniform4i), meth_QOpenGLFunctions_4_1_Core_glUniform4i, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4i)},
    {SIP_MLNAME_CAST(sipName_glUniform4iv), meth_QOpenGLFunctions_4_1_Core_glUniform4iv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4iv)},
    {SIP_MLNAME_CAST(sipName_glUniform4ui), meth_QOpenGLFunctions_4_1_Core_glUniform4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniform4ui)},
    {SIP_MLNAME_CAST(sipName_glUniformBlockBinding), meth_QOpenGLFunctions_4_1_Core_glUniformBlockBinding, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniformBlockBinding)},
    {SIP_MLNAME_CAST(sipName_glUniformMatrix2fv), meth_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix2fv)},
    {SIP_MLNAME_CAST(sipName_glUniformMatrix3fv), meth_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix3fv)},
    {SIP_MLNAME_CAST(sipName_glUniformMatrix4fv), meth_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUniformMatrix4fv)},
    {SIP_MLNAME_CAST(sipName_glUnmapBuffer), meth_QOpenGLFunctions_4_1_Core_glUnmapBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUnmapBuffer)},
    {SIP_MLNAME_CAST(sipName_glUseProgram), meth_QOpenGLFunctions_4_1_Core_glUseProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUseProgram)},
    {SIP_MLNAME_CAST(sipName_glUseProgramStages), meth_QOpenGLFunctions_4_1_Core_glUseProgramStages, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glUseProgramStages)},
    {SIP_MLNAME_CAST(sipName_glValidateProgram), meth_QOpenGLFunctions_4_1_Core_glValidateProgram, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glValidateProgram)},
    {SIP_MLNAME_CAST(sipName_glValidateProgramPipeline), meth_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glValidateProgramPipeline)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribDivisor), meth_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribDivisor)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribL1d), meth_QOpenGLFunctions_4_1_Core_glVertexAttribL1d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL1d)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribL2d), meth_QOpenGLFunctions_4_1_Core_glVertexAttribL2d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL2d)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribL3d), meth_QOpenGLFunctions_4_1_Core_glVertexAttribL3d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL3d)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribL4d), meth_QOpenGLFunctions_4_1_Core_glVertexAttribL4d, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribL4d)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribP1ui), meth_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP1ui)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribP2ui), meth_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP2ui)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribP3ui), meth_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP3ui)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribP4ui), meth_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribP4ui)},
    {SIP_MLNAME_CAST(sipName_glVertexAttribPointer), meth_QOpenGLFunctions_4_1_Core_glVertexAttribPointer, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexAttribPointer)},
    {SIP_MLNAME_CAST(sipName_glVertexP2ui), meth_QOpenGLFunctions_4_1_Core_glVertexP2ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexP2ui)},
    {SIP_MLNAME_CAST(sipName_glVertexP3ui), meth_QOpenGLFunctions_4_1_Core_glVertexP3ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexP3ui)},
    {SIP_MLNAME_CAST(sipName_glVertexP4ui), meth_QOpenGLFunctions_4_1_Core_glVertexP4ui, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glVertexP4ui)},
    {SIP_MLNAME_CAST(sipName_glViewport), meth_QOpenGLFunctions_4_1_Core_glViewport, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glViewport)},
    {SIP_MLNAME_CAST(sipName_glViewportIndexedf), meth_QOpenGLFunctions_4_1_Core_glViewportIndexedf, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_glViewportIndexedf)},
    {SIP_MLNAME_CAST(sipName_initializeOpenGLFunctions), meth_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions, METH_VARARGS, SIP_MLDOC_CAST(doc_QOpenGLFunctions_4_1_Core_initializeOpenGLFunctions)}
};

PyDoc_STRVAR(doc_QOpenGLFunctions_4_1_Core, "\1QOpenGLFunctions_4_1_Core()");


pyqt5ClassTypeDef sipTypeDef__QOpenGLFunctions_4_1_Core_QOpenGLFunctions_4_1_Core = {
{
    {
        -1,
        0,
        0,
        SIP_TYPE_SUPER_INIT|SIP_TYPE_CLASS,
        sipNameNr_QOpenGLFunctions_4_1_Core,
        {0}
    },
    {
        sipNameNr_QOpenGLFunctions_4_1_Core,
        {0, 0, 1},
        263, methods_QOpenGLFunctions_4_1_Core,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QOpenGLFunctions_4_1_Core,
    -1,
    -1,
    supers_QOpenGLFunctions_4_1_Core,
    0,
    init_type_QOpenGLFunctions_4_1_Core,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QOpenGLFunctions_4_1_Core,
    0,
    0,
    0,
    release_QOpenGLFunctions_4_1_Core,
    cast_QOpenGLFunctions_4_1_Core,
    0,
    0,
    0,
    0,
    0,
    0
},
    0,
    0,
    0,
    0
};
