I can't get basic triangle tutorial to work i have tried everything and nothing helps not even glewExperimental = GL_TRUE;

here is the code, can someone please help me with this, the program crashes on glGenVertexArrays no matter what

[source lang="cpp"]// preprocessor directives
#define WIN32_LEAN_AND_MEAN
//#define _CRT_SECURE_NO_DEPRECATE
#define DIRECTINPUT_VERSION 0x0800 // direct input version

//#pragma warning(disable : 4995) // #pragma deprecated warning
//#pragma warning(disable : 4996) // deprecated warning
//#pragma warning(disable : 4244) // possible loss of data warning

// included headers
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>

// opengl headers
#include "GL/glew.h"
#include "GL/freeglut.h"
#include "GL/glfw.h"
#include "GL/glm/glm.hpp"
#include <GL/gl.h>

// input device headers
#include <dinput.h>
#include <xinput.h>

// included libraries
#pragma comment(lib, "glew32.lib")
#pragma comment(lib, "freeglut.lib")
#pragma comment(lib, "glfw.lib")
#pragma comment(lib, "opengl32.lib")

#pragma comment(lib, "dinput8.lib")
#pragma comment(lib, "xinput.lib")

// namespace
using namespace glm;
using namespace std;

// function prototypes
GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path);

// main
int main(int argc, char *argv[])
{
int running = GL_TRUE;
double time;

glewExperimental = GL_TRUE;

// Initialize GLFW
if(!glfwInit())
exit(EXIT_FAILURE);

glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 0);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);

// position window in the center of the screen
GLFWvidmode DesktopSize;
int width = 800;
int height = 600;

// Open an OpenGL window
if(!glfwOpenWindow(800, 600, 0, 0, 0, 0, 32, 8, GLFW_WINDOW))
{
glfwTerminate();
exit(EXIT_FAILURE);
}

// disable maximize button
HWND windowHandle = GetForegroundWindow();
long Style = GetWindowLong(windowHandle, GWL_STYLE);
Style &amp;= ~WS_MAXIMIZEBOX; //this makes it still work when WS_MAXIMIZEBOX is actually already toggled off
SetWindowLong(windowHandle, GWL_STYLE, Style);

glfwGetDesktopMode(&amp;DesktopSize);
glfwSetWindowPos((DesktopSize.Width - width) / 2, (DesktopSize.Height - height) / 4);

// setup viewport
glViewport(0, 0, width, height);

// setup projection matrix
float znear = 0.1f;
float zfar = 1000.0f;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, 1.0f, 1.0f, 0.0f, znear, zfar);

// setup aspect ratio according to screen resolution
// and set fov
float fov = 45.0f; // 90 degrees
gluPerspective(fov, width/height, znear, zfar);

// clear the screen to mid gray
glClearColor(0.5f, 0.5f, 0.5f, 0.0f);

// create vertex array object
GLuint VertexArrayID;
glGenVertexArrays(1, &amp;VertexArrayID);
glBindVertexArray(VertexArrayID);

// compile the shader
GLuint programID = LoadShaders("data/shaders/red.vert", "data/shaders/red.frag");

// vertex positions
static const GLfloat g_vertex_buffer_data[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
};

// create vertex buffer
GLuint vertexbuffer;
glGenBuffers(1, &amp;vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

// Main loop
while(running)
{
time = glfwGetTime();

// OpenGL rendering goes here
glClear(GL_COLOR_BUFFER_BIT);

// use color shader
glUseProgram(programID);

// Select and setup the projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fov, width/height, znear, zfar);

// Select and setup the modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt(0.0f, 1.0f, 0.0f, // Eye-position
0.0f, 0.0f/*20.0f*/, 0.0f, // View-point
0.0f, 0.0f, 1.0f); // Up-vector

// Draw a rotating triangle


// 1rst attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glVertexAttribPointer(
0, // attribute 0. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);

// Draw the triangle !
glDrawArrays(GL_TRIANGLES, 0, 3); // From index 0 to 3 -> 1 triangle

glDisableVertexAttribArray(0);

// Swap front and back rendering buffers
glfwSwapBuffers();

// use vsync based on refresh rate
//glfwSwapInterval(1);

// Check if ESC key was pressed or window was closed
running = !glfwGetKey(GLFW_KEY_ESC) &amp;&amp; glfwGetWindowParam(GLFW_OPENED);
}

// Close window and terminate GLFW
glfwTerminate();

// clean up vertex buffer object
glDeleteBuffers(1, &amp;vertexbuffer);
glDeleteVertexArrays(1, &amp;VertexArrayID);

// Exit program
exit(EXIT_SUCCESS);

return 0;
}

GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path)
{
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);

// Read the Vertex Shader code from the file
string VertexShaderCode;
ifstream VertexShaderStream(vertex_file_path, ios::in);
if(VertexShaderStream.is_open()){
string Line = "";
while(getline(VertexShaderStream, Line))
VertexShaderCode += "\n" + Line;
VertexShaderStream.close();
}

// Read the Fragment Shader code from the file
string FragmentShaderCode;
ifstream FragmentShaderStream(fragment_file_path, ios::in);
if(FragmentShaderStream.is_open()){
string Line = "";
while(getline(FragmentShaderStream, Line))
FragmentShaderCode += "\n" + Line;
FragmentShaderStream.close();
}

GLint Result = GL_FALSE;
int InfoLogLength;

// Compile Vertex Shader
printf("Compiling shader : %s\n", vertex_file_path);
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &amp;VertexSourcePointer , NULL);
glCompileShader(VertexShaderID);

// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &amp;Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &amp;InfoLogLength);
vector<char> VertexShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &amp;VertexShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &amp;VertexShaderErrorMessage[0]);

// Compile Fragment Shader
printf("Compiling shader : %s\n", fragment_file_path);
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &amp;FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);

// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &amp;Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &amp;InfoLogLength);
vector<char> FragmentShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &amp;FragmentShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &amp;FragmentShaderErrorMessage[0]);

// Link the program
fprintf(stdout, "Linking program\n");
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);

// Check the program
glGetProgramiv(ProgramID, GL_LINK_STATUS, &amp;Result);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &amp;InfoLogLength);
//vector<char> ProgramErrorMessage(max(InfoLogLength, int(1)));
//glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &amp;ProgramErrorMessage[0]);
//fprintf(stdout, "%s\n", &amp;ProgramErrorMessage[0]);

glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);

return ProgramID;
}[/source]

Ok that fixed the crash i had, but now i can't get triangle on the screen, i even tried to copy/paste entire main from tutorial to my project and it still doesnt show the triangle. I have absolutely no idea why is this. Can you help? I found tutorial here http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/