text: #include "IntroRenderer.h"
  #include <math.h>
  #include <stdlib.h>
  #include <jni.h>
  
  static int32_t is_initialized = 0;
  static float _coefficientsX[TIMING_NUM][4], _coefficientsY[TIMING_NUM][4];
  static const float _c0x = 0.0;
  static const float _c0y = 0.0;
  static const float _c3x = 1.0;
  static const float _c3y = 1.0;
  
  float scale_factor;
  int width, height;
  int y_offset_absolute;
  static TextureProgram texture_program;
  static TextureProgram texture_program_one;
  static TextureProgram texture_program_red;
  static TextureProgram texture_program_blue;
  static TextureProgram texture_program_light_red;
  static TextureProgram texture_program_light_blue;
  static TextureProgram *texture_program_temp;
  static ColorProgram color_program;
  static float y_offset;
  
  #define BUFFER_OFFSET(i) ((void*)(i))
  
  static const vec4 black_color = {0.0f, 0.0f, 0.0f, 1.0f};
  static const vec4 white_color = {1.0f, 1.0f, 1.0f, 1.0f};
  
  static LayerParams ribbonLayer, privateLayer;
  
  static TexturedShape spiral;
  static Shape mask1;
  static Shape cloud_extra_mask1;
  static Shape cloud_extra_mask2;
  static Shape cloud_extra_mask3;
  static Shape cloud_extra_mask4;
  
  static Shape cloud_cover;
  
  static Shape free_bg;
  static TexturedShape fast_body;
  static TexturedShape fast_arrow_shadow;
  static TexturedShape fast_arrow;
  
  static TexturedShape free_knot1;
  static TexturedShape free_knot2;
  static TexturedShape free_knot3;
  static TexturedShape free_knot4;
  
  static Shape powerful_bg;
  static TexturedShape powerful_mask, powerful_infinity, powerful_infinity_white;
  
  static Shape private_bg;
  
  static TexturedShape telegram_sphere, telegram_plane;
  
  static Shape cloud_bg;
  
  #define starsCount 80
  static TexturedShape star;
  static Params stars[starsCount];
  
  static Shape ribbon1;
  static Shape ribbon2;
  static Shape ribbon3;
  static Shape ribbon4;
  static mat4x4 stars_matrix;
  static mat4x4 main_matrix;
  static mat4x4 ribbons_layer;
  
  static TexturedShape ic_bubble_dot, ic_bubble, ic_cam_lens, ic_cam, ic_pencil, ic_pin, ic_smile_eye, ic_smile, ic_videocam;
  static GLuint ic_bubble_dot_texture, ic_bubble_texture, ic_cam_lens_texture, ic_cam_texture, ic_pencil_texture, ic_pin_texture, ic_smile_eye_texture, ic_smile_texture, ic_videocam_texture;
  static GLuint telegram_sphere_texture, telegram_plane_texture;
  static GLuint fast_spiral_texture, fast_body_texture, fast_arrow_texture, fast_arrow_shadow_texture;
  static GLuint free_knot_up_texture, free_knot_down_texture;
  static GLuint powerful_mask_texture, powerful_star_texture, powerful_infinity_texture, powerful_infinity_white_texture;
  static GLuint private_door_texture, private_screw_texture, private_keyhole_body_texture;
  static Shape infinity;
  
  static TexturedShape private_door, private_screw, private_keyhole_body;
  static Shape private_stroke;
  
  static Shape start_button;
  
  static const float r1 = 58.5f;
  static const float r2 = 70;
  static double ms0;
  static float date, date0;
  static float duration_const = 0.3f;
  static int32_t direct;
  static int32_t i;
  static int32_t current_page, prev_page;
  static float time;
  static mat4x4 ic_matrix;
  static LayerParams ic_pin_layer, ic_cam_layer, ic_videocam_layer, ic_smile_layer, ic_bubble_layer, ic_pencil_layer;
  static float time_local = 0;
  static float knot_delays[4];
  static float offset_y;
  static float ribbonLength = 86.5f;
  static int32_t starsFar = 500;
  static float scroll_offset;
  
  static float calculated_speedometer_sin;
  float ms0_anim;
  int fps_anim;
  int count_anim_fps;
  static float speedometer_scroll_offset = 0, free_scroll_offset = 0, private_scroll_offset = 0;
  float anim_pencil_start_time, anim_pencil_start_all_time, anim_pencil_start_all_end_time;
  int anim_pencil_stage;
  int anim_bubble_dots_stage;
  int anim_bubble_dots_end_period;
  float anim_videocam_start_time, anim_videocam_next_time, anim_videocam_duration, anim_videocam_angle, anim_videocam_old_angle;
  float anim_cam_start_time, anim_cam_next_time, anim_cam_duration, anim_cam_angle, anim_cam_old_angle;
  CPoint anim_cam_position, anim_cam_old_position;
  int qShot;
  float anim_camshot_start_time, anim_camshot_duration;
  float anim_smile_start_time1, anim_smile_start_time2, anim_smile_blink_start_time;
  int anim_smile_blink_one;
  int anim_smile_stage;
  static float scale;
  float anim_pin_start_time, anim_pin_duration;
  static int32_t anim_pencil_period;
  static mat4x4 private_matrix;
  float cloud_scroll_offset;
  
  static inline void vec2_add(vec2 r, vec2 a, vec2 b) {
      int32_t i;
      for (i = 0; i < 2; ++i) {
          r[i] = a[i] + b[i];
      }
  }
  
  static inline float vec2_mul_inner(vec2 a, vec2 b) {
      float p = 0.f;
      int32_t i;
      for (i = 0; i < 2; ++i) {
          p += b[i] * a[i];
      }
      return p;
  }
  
  static inline float vec2_len(vec2 v) {
      return sqrtf(vec2_mul_inner(v, v));
  }
  
  static inline void vec2_scale(vec2 r, vec2 v, float s) {
      int32_t i;
      for (i = 0; i < 2; ++i) {
          r[i] = v[i] * s;
      }
  }
  
  static inline void vec2_norm(vec2 r, vec2 v) {
      float k = 1.f / vec2_len(v);
      vec2_scale(r, v, k);
  }
  
  static inline void mat4x4_identity(mat4x4 M) {
      int32_t i, j;
      for (i = 0; i < 4; ++i) {
          for (j = 0; j < 4; ++j) {
              M[i][j] = i == j ? 1.f : 0.f;
          }
      }
  }
  
  static inline void mat4x4_dup(mat4x4 M, mat4x4 N) {
      int32_t i, j;
      for (i = 0; i < 4; ++i) {
          for (j = 0; j < 4; ++j) {
              M[i][j] = N[i][j];
          }
      }
  }
  
  static inline void vec4_scale(vec4 r, vec4 v, float s) {
      int32_t i;
      for (i = 0; i < 4; ++i) {
          r[i] = v[i] * s;
      }
  }
  
  static inline void mat4x4_scale_aniso(mat4x4 M, mat4x4 a, float x, float y, float z) {
      vec4_scale(M[0], a[0], x);
      vec4_scale(M[1], a[1], y);
      vec4_scale(M[2], a[2], z);
  }
  
  static inline void mat4x4_mul(mat4x4 M, mat4x4 a, mat4x4 b) {
      int32_t k, r, c;
      for (c = 0; c < 4; ++c) {
          for (r = 0; r < 4; ++r) {
              M[c][r] = 0.f;
              for (k = 0; k < 4; ++k) {
                  M[c][r] += a[k][r] * b[c][k];
              }
          }
      }
  }
  
  static inline void mat4x4_mul_vec4(vec4 r, mat4x4 M, vec4 v) {
      int32_t i, j;
      for (j = 0; j < 4; ++j) {
          r[j] = 0.f;
          for (i = 0; i < 4; ++i) {
              r[j] += M[i][j] * v[i];
          }
      }
  }
  
  static inline void mat4x4_translate(mat4x4 T, float x, float y, float z) {
      mat4x4_identity(T);
      T[3][0] = x;
      T[3][1] = y;
      T[3][2] = z;
  }
  
  static inline void mat4x4_rotate_Z2(mat4x4 Q, mat4x4 M, float angle) {
      float s = sinf(angle);
      float c = cosf(angle);
      mat4x4 R = {
              {c,   s,   0.f, 0.f},
              {-s,  c,   0.f, 0.f},
              {0.f, 0.f, 1.f, 0.f},
              {0.f, 0.f, 0.f, 1.f}
      };
      mat4x4_mul(Q, M, R);
  }
  
  static inline void mat4x4_rotate_Z(mat4x4 Q, float angle) {
      mat4x4 temp;
      mat4x4_dup(temp, Q);
      mat4x4_rotate_Z2(Q, temp, angle);
  }
  
  static inline void mat4x4_translate_in_place(mat4x4 m, float x, float y, float z) {
      int32_t i;
      for (i = 0; i < 4; ++i) {
          m[3][i] += m[0][i] * x + m[1][i] * y + m[2][i] * z;
      }
  }
  
  static inline float deg_to_radf(float deg) {
      return deg * (float) M_PI / 180.0f;
  }
  
  static inline float MAXf(float a, float b) {
      return a > b ? a : b;
  }
  
  static inline float MINf(float a, float b) {
      return a < b ? a : b;
  }
  
  GLuint compile_shader(const GLenum type, const GLchar* source, const GLint length) {
      GLuint shader_object_id = glCreateShader(type);
      GLint compile_status;
      glShaderSource(shader_object_id, 1, &source, &length);
      glCompileShader(shader_object_id);
      glGetShaderiv(shader_object_id, GL_COMPILE_STATUS, &compile_status);
      return shader_object_id;
  }
  
  GLuint link_program(const GLuint vertex_shader, const GLuint fragment_shader) {
      GLuint program_object_id = glCreateProgram();
      GLint link_status;
      glAttachShader(program_object_id, vertex_shader);
      glAttachShader(program_object_id, fragment_shader);
      glLinkProgram(program_object_id);
      glGetProgramiv(program_object_id, GL_LINK_STATUS, &link_status);
      return program_object_id;
  }
  
  GLuint build_program(const GLchar * vertex_shader_source, const GLint vertex_shader_source_length, const GLchar * fragment_shader_source, const GLint fragment_shader_source_length) {
      GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_shader_source, vertex_shader_source_length);
      GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_shader_source, fragment_shader_source_length);
      return link_program(vertex_shader, fragment_shader);
  }
  
  GLuint create_vbo(const GLsizeiptr size, const GLvoid* data, const GLenum usage) {
      GLuint vbo_object;
      glGenBuffers(1, &vbo_object);
      glBindBuffer(GL_ARRAY_BUFFER, vbo_object);
      glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr) size, data, usage);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
      return vbo_object;
  }
  
  TextureProgram get_texture_program(GLuint program) {
      return (TextureProgram) {
              program,
              (GLuint) glGetAttribLocation(program, "a_Position"),
              (GLuint) glGetAttribLocation(program, "a_TextureCoordinates"),
              glGetUniformLocation(program, "u_MvpMatrix"),
              glGetUniformLocation(program, "u_TextureUnit"),
              glGetUniformLocation(program, "u_Alpha")};
  }
  
  ColorProgram get_color_program(GLuint program) {
      return (ColorProgram) {
              program,
              (GLuint) glGetAttribLocation(program, "a_Position"),
              glGetUniformLocation(program, "u_MvpMatrix"),
              glGetUniformLocation(program, "u_Color"),
              glGetUniformLocation(program, "u_Alpha")};
  }
  
  float frand(float from, float to) {
      return (float) (((double) random() / RAND_MAX) * (to - from) + from);
  }
  
  int irand(int32_t from, int32_t to) {
      return (int32_t) (((double) random() / RAND_MAX) * (to - from + 1) + from);
  }
  
  int signrand() {
      return irand(0, 1) * 2 - 1;
  }
  
  static inline float evaluateAtParameterWithCoefficients(float t, float coefficients[]) {
      return coefficients[0] + t * coefficients[1] + t * t * coefficients[2] + t * t * t * coefficients[3];
  }
  
  static inline float evaluateDerivationAtParameterWithCoefficients(float t, float coefficients[]) {
      return coefficients[1] + 2 * t * coefficients[2] + 3 * t * t * coefficients[3];
  }
  
  static inline float calcParameterViaNewtonRaphsonUsingXAndCoefficientsForX(float x, float coefficientsX[]) {
      float t = x;
      int32_t i;
      for (i = 0; i < 10; i++) {
          float x2 = evaluateAtParameterWithCoefficients(t, coefficientsX) - x;
          float d = evaluateDerivationAtParameterWithCoefficients(t, coefficientsX);
          float dt = x2 / d;
          t = t - dt;
      }
      return t;
  }
  
  float timing(float x, timing_type type) {
      if (is_initialized == 0) {
          is_initialized = 1;
  
          float c[TIMING_NUM][4];
          c[Default][0] = 0.25f;
          c[Default][1] = 0.1f;
          c[Default][2] = 0.25f;
          c[Default][3] = 1.0f;
          c[EaseInEaseOut][0] = 0.42f;
          c[EaseInEaseOut][1] = 0.0f;
          c[EaseInEaseOut][2] = 0.58f;
          c[EaseInEaseOut][3] = 1.0f;
          c[EaseIn][0] = 0.42f;
          c[EaseIn][1] = 0.0f;
          c[EaseIn][2] = 1.0f;
          c[EaseIn][3] = 1.0f;
          c[EaseOut][0] = 0.0f;
          c[EaseOut][1] = 0.0f;
          c[EaseOut][2] = 0.58f;
          c[EaseOut][3] = 1.0f;
          c[EaseOutBounce][0] = 0.0f;
          c[EaseOutBounce][1] = 0.0f;
          c[EaseOutBounce][2] = 0.0f;
          c[EaseOutBounce][3] = 1.25;
          c[Linear][0] = 0.0;
          c[Linear][1] = 0.0;
          c[Linear][2] = 1.0;
          c[Linear][3] = 1.0;
          int32_t i;
          for (i = 0; i < TIMING_NUM; i++) {
              float _c1x = c[i][0];
              float _c1y = c[i][1];
              float _c2x = c[i][2];
              float _c2y = c[i][3];
              _coefficientsX[i][0] = _c0x;
              _coefficientsX[i][1] = -3.0f * _c0x + 3.0f * _c1x;
              _coefficientsX[i][2] = 3.0f * _c0x - 6.0f * _c1x + 3.0f * _c2x;
              _coefficientsX[i][3] = -_c0x + 3.0f * _c1x - 3.0f * _c2x + _c3x;
              _coefficientsY[i][0] = _c0y;
              _coefficientsY[i][1] = -3.0f * _c0y + 3.0f * _c1y;
              _coefficientsY[i][2] = 3.0f * _c0y - 6.0f * _c1y + 3.0f * _c2y;
              _coefficientsY[i][3] = -_c0y + 3.0f * _c1y - 3.0f * _c2y + _c3y;
          }
      }
  
      if (x == 0.0 || x == 1.0) {
          return x;
      }
      float t = calcParameterViaNewtonRaphsonUsingXAndCoefficientsForX(x, _coefficientsX[type]);
      float y = evaluateAtParameterWithCoefficients(t, _coefficientsY[type]);
      return y;
  }
  
  void set_y_offset_objects(float a) {
      y_offset = a;
  }
  
  void setup_shaders() {
      const char *vshader =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "void main(){"
                      "   gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      const char *fshader =
              "precision lowp float;"
                      "uniform vec4 u_Color;"
                      "uniform float u_Alpha;"
                      "void main() {"
                      "   gl_FragColor = u_Color;"
                      "   gl_FragColor.w*=u_Alpha;"
                      "}";
  
      color_program = get_color_program(build_program(vshader, (GLint) strlen(vshader), fshader, (GLint) strlen(fshader)));
  
      const char *vshader_texture =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      const char *fshader_texture =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "    gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "    gl_FragColor.w *= u_Alpha;"
                      "}";
  
      texture_program = get_texture_program(build_program(vshader_texture, (GLint) strlen(vshader_texture), fshader_texture, (GLint) strlen(fshader_texture)));
  
      const char *vshader_texture_blue =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      const char *fshader_texture_blue =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "    gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "   float p = u_Alpha*gl_FragColor.w;"
                      "   gl_FragColor = vec4(0,0.6,0.898,p);"
                      "}";
  
      texture_program_blue = get_texture_program(build_program(vshader_texture_blue, (GLint) strlen(vshader_texture_blue), fshader_texture_blue, (GLint) strlen(fshader_texture_blue)));
  
      const char *vshader_texture_red =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      const char *fshader_texture_red =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "   gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "   float p = gl_FragColor.w*u_Alpha;"
                      "   gl_FragColor = vec4(210./255.,57./255.,41./255.,p);"
                      "}";
  
      texture_program_red = get_texture_program(build_program(vshader_texture_red, (GLint) strlen(vshader_texture_red), fshader_texture_red, (GLint) strlen(fshader_texture_red)));
  
      vshader =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      fshader =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "    gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "    float p = u_Alpha*gl_FragColor.w;"
                      "    gl_FragColor = vec4(246./255., 73./255., 55./255., p);"
                      "}";
  
      texture_program_light_red = get_texture_program(build_program(vshader, (GLint) strlen(vshader), fshader, (GLint) strlen(fshader)));
  
      vshader =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      fshader =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "    gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "    float p = u_Alpha*gl_FragColor.w;"
                      "    gl_FragColor = vec4(42./255.,180./255.,247./255.,p);"
                      "}";
  
      texture_program_light_blue = get_texture_program(build_program(vshader, (GLint) strlen(vshader), fshader, (GLint) strlen(fshader)));
  
      vshader =
              "uniform mat4 u_MvpMatrix;"
                      "attribute vec4 a_Position;"
                      "attribute vec2 a_TextureCoordinates;"
                      "varying vec2 v_TextureCoordinates;"
                      "void main(){"
                      "    v_TextureCoordinates = a_TextureCoordinates;"
                      "    gl_Position = u_MvpMatrix * a_Position;"
                      "}";
  
      fshader =
              "precision lowp float;"
                      "uniform sampler2D u_TextureUnit;"
                      "varying vec2 v_TextureCoordinates;"
                      "uniform float u_Alpha;"
                      "void main(){"
                      "    gl_FragColor = texture2D(u_TextureUnit, v_TextureCoordinates);"
                      "    gl_FragColor *= u_Alpha;"
                      "}";
  
      texture_program_one = get_texture_program(build_program(vshader, (GLint) strlen(vshader), fshader, (GLint) strlen(fshader)));
  }
  
  CPoint CPointMake(float x, float y) {
      CPoint p = {x, y};
      return p;
  }
  
  CSize CSizeMake(float width, float height) {
      CSize s = {width, height};
      return s;
  }
  
  float D2R(float a) {
      return (float) (a * M_PI / 180.0);
  }
  
  float R2D(float a) {
      return (float) (a * 180.0 / M_PI);
  }
  
  xyz xyzMake(float x, float y, float z) {
      xyz result;
      result.x = x;
      result.y = y;
      result.z = z;
      return result;
  }
  
  LayerParams default_layer_params() {
      LayerParams params;
      params.anchor.x = params.anchor.y = params.anchor.z = 0;
      params.position.x = params.position.y = params.position.z = 0;
      params.rotation = 0;
      params.scale.x = params.scale.y = params.scale.z = 1.0f;
      return params;
  }
  
  Params default_params() {
      Params params;
      params.anchor.x = params.anchor.y = params.anchor.z = 0.0f;
      params.position.x = params.position.y = params.position.z = 0.0f;
      params.rotation = 0;
      params.scale.x = params.scale.y = params.scale.z = 1.0f;
      params.alpha = 1.0f;
      params.var_params.side_length = 0;
      params.var_params.start_angle = 0;
      params.var_params.end_angle = 0;
      params.var_params.angle = 0;
      params.var_params.size = CSizeMake(0, 0);
      params.var_params.radius = 0;
      params.var_params.width = 0;
      params.const_params.is_star = 0;
      params.layer_params = default_layer_params();
      return params;
  }
  
  void mat4x4_translate_independed(mat4x4 m, float x, float y, float z) {
      mat4x4 tr;
      mat4x4_identity(tr);
      mat4x4_translate_in_place(tr, x, y, z);
      mat4x4 m_dup;
      mat4x4_dup(m_dup, m);
      mat4x4_mul(m, tr, m_dup);
  }
  
  static inline void mvp_matrix(mat4x4 model_view_projection_matrix, Params params, mat4x4 view_projection_matrix) {
      mat4x4 model_matrix;
      mat4x4_identity(model_matrix);
      mat4x4 id;
      mat4x4_identity(id);
      mat4x4_translate(model_matrix, -params.anchor.x, -params.anchor.y, params.anchor.z);
      mat4x4 scaled;
      mat4x4_identity(scaled);
      mat4x4_scale_aniso(scaled, scaled, params.scale.x, -params.scale.y, params.scale.z);
      mat4x4 tmp;
      mat4x4_dup(tmp, model_matrix);
      mat4x4_mul(model_matrix, scaled, tmp);
      mat4x4 rotate;
      mat4x4_dup(rotate, id);
      mat4x4_rotate_Z2(rotate, id, deg_to_radf(-params.rotation));
      mat4x4_dup(tmp, model_matrix);
      mat4x4_mul(model_matrix, rotate, tmp);
      mat4x4_translate_independed(model_matrix, params.position.x, -params.position.y, params.position.z);
      mat4x4 model_matrix3;
      mat4x4_identity(model_matrix3);
      mat4x4 mm;
      mat4x4_mul(mm, model_matrix3, view_projection_matrix);
      mat4x4_mul(model_view_projection_matrix, mm, model_matrix);
      mat4x4_translate_independed(model_view_projection_matrix, 0, -y_offset / view_projection_matrix[3][3], 0);
  }
  
  void draw_shape(const Shape* shape, mat4x4 view_projection_matrix) {
      if (shape->params.alpha > 0 && (fabs(shape->params.scale.x) > 0 && fabs(shape->params.scale.y) > 0 && fabs(shape->params.scale.z) > 0)) {
          mat4x4 model_view_projection_matrix;
          mvp_matrix(model_view_projection_matrix, shape->params, view_projection_matrix);
          glUseProgram(color_program.program);
          glUniformMatrix4fv(color_program.u_mvp_matrix_location, 1, GL_FALSE, (GLfloat *) model_view_projection_matrix);
          if (shape->params.rotation == 5.0f) {
              glUniform4fv(color_program.u_color_location, 1, shape->color);
          } else if (shape->params.rotation == 10.0f) {
              vec4 col = {0, 1, 0, 1};
              glUniform4fv(color_program.u_color_location, 1, col);
          } else {
              glUniform4fv(color_program.u_color_location, 1, shape->color);
          }
          glUniform1f(color_program.u_alpha_loaction, shape->params.alpha);
          glVertexAttribPointer(color_program.a_position_location, 2, GL_FLOAT, GL_FALSE, sizeof(CPoint), &shape->data[0].x);
          glEnableVertexAttribArray(color_program.a_position_location);
          glDrawArrays(shape->params.const_params.triangle_mode, 0, shape->num_points);
      }
  }
  
  void draw_textured_shape(const TexturedShape* shape, mat4x4 view_projection_matrix, texture_program_type program_type) {
      if (shape->params.alpha > 0 && (fabs(shape->params.scale.x) > 0 && fabs(shape->params.scale.y) > 0 && fabs(shape->params.scale.z) > 0)) {
          mat4x4 model_view_projection_matrix;
          mvp_matrix(model_view_projection_matrix, shape->params, view_projection_matrix);
          if (shape->params.const_params.is_star == 1) {
              vec4 pos;
              vec4 vertex = {0, 0, 0, 1};
              mat4x4_mul_vec4(pos, model_view_projection_matrix, vertex);
              vec4 p_NDC = {pos[0] / pos[3], pos[1] / pos[3], pos[2] / pos[3], pos[3] / pos[3]};
              vec4 p_window = {p_NDC[0] * width, -p_NDC[1] * height, 0, 0};
              int32_t d = 160;
              if (fabs(p_window[0]) > d || p_window[1] > y_offset_absolute * 2 + d || p_window[1] < y_offset_absolute * 2 - d) {
                  return;
              }
          }
          if (program_type == RED) {
              texture_program_temp = &texture_program_red;
          } else if (program_type == BLUE) {
              texture_program_temp = &texture_program_blue;
          } else if (program_type == LIGHT_RED) {
              texture_program_temp = &texture_program_light_red;
          } else if (program_type == LIGHT_BLUE) {
              texture_program_temp = &texture_program_light_blue;
          } else if (program_type == NORMAL_ONE) {
              texture_program_temp = &texture_program_one;
          } else {
              texture_program_temp = &texture_program;
          }
  
  
          glUseProgram(texture_program_temp->program);
  
          glActiveTexture(GL_TEXTURE0);
          glBindTexture(GL_TEXTURE_2D, shape->texture);
          glUniformMatrix4fv(texture_program_temp->u_mvp_matrix_location, 1, GL_FALSE, (GLfloat *) model_view_projection_matrix);
          glUniform1i(texture_program_temp->u_texture_unit_location, 0);
          glUniform1f(texture_program_temp->u_alpha_loaction, shape->params.alpha);
  
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glVertexAttribPointer(texture_program_temp->a_position_location, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GL_FLOAT), BUFFER_OFFSET(0));
          glVertexAttribPointer(texture_program_temp->a_texture_coordinates_location, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GL_FLOAT), BUFFER_OFFSET(2 * sizeof(GL_FLOAT)));
          glEnableVertexAttribArray(texture_program_temp->a_position_location);
          glEnableVertexAttribArray(texture_program_temp->a_texture_coordinates_location);
          glDrawArrays(shape->params.const_params.triangle_mode, 0, shape->num_points);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  static inline void gen_rounded_rectangle(CPoint* out, CSize size, float radius, int32_t round_count) {
      int32_t offset = 0;
      out[offset++] = CPointMake(0, 0);
      float k = (float) (M_PI / 2 / (round_count + 1));
      int32_t i = 0;
      int32_t n = 0;
      for (i = (round_count + 2) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * radius, size.height / 2 - radius + sinf(i * k) * radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * radius, size.height / 2 - radius + sinf(i * k) * radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * radius, -size.height / 2 + radius + sinf(i * k) * radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * radius, -size.height / 2 + radius + sinf(i * k) * radius);
      }
      out[offset] = CPointMake(size.width / 2, size.height / 2 - radius);
  }
  
  Shape create_rounded_rectangle(CSize size, float radius, int32_t round_count, const vec4 color) {
      int32_t real_vertex_count = 4 * (2 + round_count) + 2;
  
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2;
      params.const_params.round_count = round_count;
      params.const_params.triangle_mode = GL_TRIANGLE_FAN;
  
      params.var_params.size = size;
      params.var_params.radius = radius;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_rounded_rectangle(data, params.var_params.size, params.var_params.radius, params.const_params.round_count);
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  void change_rounded_rectangle(Shape* shape, CSize size, float radius) {
      if ((*shape).params.var_params.size.width != size.width || (*shape).params.var_params.size.height != size.height || (*shape).params.var_params.radius != radius) {
          (*shape).params.var_params.size.width = size.width;
          (*shape).params.var_params.size.height = size.height;
          (*shape).params.var_params.radius = radius;
          gen_rounded_rectangle((*shape).data, (*shape).params.var_params.size, (*shape).params.var_params.radius, (*shape).params.const_params.round_count);
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glBufferSubData(GL_ARRAY_BUFFER, 0, shape->params.const_params.datasize, shape->data);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  static inline CPoint square_point(float angle, float radius) {
      CPoint p = {0.0f, 0.0f};
      if (angle <= M_PI / 2 * 0.5f || angle > M_PI / 2 * 3.5f) {
          p = CPointMake(radius, radius * sinf(angle) / cosf(angle));
      } else if (angle <= M_PI / 2 * 1.5) {
          p = CPointMake(radius * cosf(angle) / sinf(angle), radius);
      } else if (angle <= M_PI / 2 * 2.5) {
          p = CPointMake(-radius, -radius * sinf(angle) / cosf(angle));
      } else if (angle <= (float) (M_PI / 2 * 3.5)) {
          p = CPointMake(-radius * cosf(angle) / sinf(angle), -radius);
      }
      return p;
  }
  
  static inline CPoint square_texture_point(CPoint p, float side_length) {
      return CPointMake((-p.x / side_length * 0.5f + 0.5f), -p.y / side_length * 0.5f + 0.5f);
  }
  
  static inline void gen_segmented_square(CPoint* out, float side_length, float start_angle, float end_angle) {
      CPoint p;
      float radius = side_length;
      int32_t offset = 0;
      float k = 1;
      float da = D2R(-2.6f * 2) * k;
      p = CPointMake(sinf(start_angle + end_angle) * 6 * k, -cosf(start_angle + end_angle) * 6 * k);
      out[offset++] = p;
      out[offset++] = square_texture_point(p, side_length);
      p = square_point(start_angle + da, radius);
      out[offset++] = p;
      out[offset++] = square_texture_point(p, side_length);
      int32_t q = 0;
      int32_t i;
      for (i = (int32_t) start_angle; i < floorf(R2D(start_angle + end_angle + da)); i++) {
          if ((i + 45) % 90 == 0) {
              p = square_point(D2R(i), radius);
              out[offset++] = p;
              out[offset++] = square_texture_point(p, side_length);
              q++;
          }
      }
      p = square_point(start_angle + end_angle + da, radius);
      out[offset++] = p;
      out[offset++] = square_texture_point(p, side_length);
      for (i = 0; i < 4 - q; i++) {
          p = square_point(start_angle + end_angle + da, radius);
          out[offset++] = p;
          out[offset++] = square_texture_point(p, side_length);
      }
  }
  
  TexturedShape create_segmented_square(float side_length, float start_angle, float end_angle, GLuint texture) {
      int32_t real_vertex_count = 7;
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2 * 2;
      params.const_params.triangle_mode = GL_TRIANGLE_FAN;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_segmented_square(data, side_length, start_angle, end_angle);
      return (TexturedShape) {texture, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  void change_segmented_square(TexturedShape* shape, float side_length, float start_angle, float end_angle) {
      if ((*shape).params.var_params.side_length != side_length || (*shape).params.var_params.start_angle != start_angle || (*shape).params.var_params.end_angle != end_angle) {
          (*shape).params.var_params.side_length = side_length;
          (*shape).params.var_params.start_angle = start_angle;
          (*shape).params.var_params.end_angle = end_angle;
          gen_segmented_square((*shape).data, side_length, start_angle, end_angle);
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glBufferSubData(GL_ARRAY_BUFFER, 0, shape->params.const_params.datasize, shape->data);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  static inline void gen_rectangle(CPoint* out, CSize size) {
      out[0] = CPointMake(-size.width / 2, -size.height / 2);
      out[1] = CPointMake(size.width / 2, -size.height / 2);
      out[2] = CPointMake(-size.width / 2, size.height / 2);
      out[3] = CPointMake(size.width / 2, size.height / 2);
  }
  
  Shape create_rectangle(CSize size, const vec4 color) {
      int32_t real_vertex_count = 4;
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count;
      params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_rectangle(data, size);
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  static inline CPoint rectangle_texture_point(CPoint p, CSize size) {
      return CPointMake(1 - (-p.x / size.width + 0.5f), p.y / size.height + 0.5f);
  }
  
  static inline void gen_textured_rectangle(CPoint* out, CSize size) {
      out[0] = CPointMake(-size.width / 2, -size.height / 2);
      out[1] = rectangle_texture_point(CPointMake(-size.width / 2, -size.height / 2), size);
      out[2] = CPointMake(size.width / 2, -size.height / 2);
      out[3] = rectangle_texture_point(CPointMake(size.width / 2, -size.height / 2), size);
      out[4] = CPointMake(-size.width / 2, size.height / 2);
      out[5] = rectangle_texture_point(CPointMake(-size.width / 2, size.height / 2), size);
      out[6] = CPointMake(size.width / 2, size.height / 2);
      out[7] = rectangle_texture_point(CPointMake(size.width / 2, size.height / 2), size);
  }
  
  TexturedShape create_textured_rectangle(CSize size, GLuint texture) {
      int32_t real_vertex_count = 4;
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2;
      params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_textured_rectangle(data, size);
      return (TexturedShape) {texture, data, create_vbo(params.const_params.datasize, data, GL_STATIC_DRAW), real_vertex_count, params};
  }
  
  static inline void gen_ribbon(CPoint* out, float length) {
      out[0] = CPointMake(-MAXf(length - 5.5f, 0), -5.5f);
      out[1] = CPointMake(0, -5.5f);
      out[2] = CPointMake(-MAXf(length, 0), 5.5f);
      out[3] = CPointMake(0, 5.5f);
  }
  
  Shape create_ribbon(float length, const vec4 color) {
      int32_t real_vertex_count = 4;
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count;
      params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
      params.var_params.side_length = length;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_ribbon(data, length);
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  void change_ribbon(Shape* shape, float length) {
      if ((*shape).params.var_params.side_length != length) {
          (*shape).params.var_params.side_length = length;
          gen_ribbon((*shape).data, length);
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glBufferSubData(GL_ARRAY_BUFFER, 0, shape->params.const_params.datasize, shape->data);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  static inline void gen_circle(CPoint* out, float radius, int32_t vertex_count) {
      int32_t offset = 0;
      out[offset++] = CPointMake(0, 0);
      int32_t i;
      for (i = 0; i <= vertex_count; i++) {
          out[offset++] = CPointMake(radius * (cosf(2 * (float) M_PI * (i / (float) vertex_count))), radius * sinf(2 * (float) M_PI * (i / (float) vertex_count)));
      }
  }
  
  Shape create_circle(float radius, int32_t vertex_count, const vec4 color) {
      int32_t real_vertex_count = vertex_count + 2;
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count;
      params.const_params.triangle_mode = GL_TRIANGLE_FAN;
      params.const_params.round_count = vertex_count;
      CPoint *data = (CPoint *) malloc((size_t) params.const_params.datasize);
      gen_circle(data, radius, vertex_count);
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_STATIC_DRAW), real_vertex_count, params};
  }
  
  int size_of_infinity_in_vertices(int32_t segment_count) {
      return (segment_count + 1) * 2;
  }
  
  static inline void gen_infinity(CPoint* out, float width, float angle, int32_t segment_count) {
      CPoint path[13];
      path[0] = CPointMake(53, 23);
      path[1] = CPointMake(49, 31);
      path[2] = CPointMake(39, 47);
      path[3] = CPointMake(22, 47);
      path[4] = CPointMake(6, 47);
      path[5] = CPointMake(0, 31);
      path[6] = CPointMake(0, 23);
      path[7] = CPointMake(0, 16);
      path[8] = CPointMake(5, 0);
      path[9] = CPointMake(23, 0);
      path[10] = CPointMake(39, 0);
      path[11] = CPointMake(48, 15);
      path[12] = CPointMake(52, 21);
      int32_t offset = 0;
      int32_t seg;
      for (seg = 0; seg <= segment_count; seg++) {
          float tt = ((float) seg / (float) segment_count) * angle;
          int32_t q = 4;
          float tstep = 1.f / q;
          int32_t n = (int32_t) floor(tt / tstep);
          CPoint a = path[0 + 3 * n];;
          CPoint p1 = path[1 + 3 * n];
          CPoint p2 = path[2 + 3 * n];
          CPoint b = path[3 + 3 * n];
          float t = (tt - tstep * n) * q;
          float nt = 1.0f - t;
  
          vec2 p = {a.x * nt * nt * nt + 3.0f * p1.x * nt * nt * t + 3.0f * p2.x * nt * t * t + b.x * t * t * t,
                    a.y * nt * nt * nt + 3.0f * p1.y * nt * nt * t + 3.0f * p2.y * nt * t * t + b.y * t * t * t};
          vec2 tangent = {-3.0f * a.x * nt * nt + 3.0f * p1.x * (1.0f - 4.0f * t + 3.0f * t * t) + 3.0f * p2.x * (2.0f * t - 3.0f * t * t) + 3.0f * b.x * t * t,
                          -3.0f * a.y * nt * nt + 3.0f * p1.y * (1.0f - 4.0f * t + 3.0f * t * t) + 3.0f * p2.y * (2.0f * t - 3.0f * t * t) + 3.0f * b.y * t * t};
  
          vec2 tan_norm = {-tangent[1], tangent[0]};
          vec2 norm;
          vec2_norm(norm, tan_norm);
  
          vec2 v;
          vec2 norm_scaled;
          vec2_scale(norm_scaled, norm, +width / 2.f);
          vec2_add(v, p, norm_scaled);
  
          out[offset] = CPointMake(v[0], v[1]);
          offset++;
  
          vec2_scale(norm_scaled, norm, -width / 2.f);
          vec2_add(v, p, norm_scaled);
  
          out[offset] = CPointMake(v[0], v[1]);
          offset++;
      }
  }
  
  Shape create_infinity(float width, float angle, int32_t segment_count, const vec4 color) {
      int32_t real_vertex_count = size_of_infinity_in_vertices(segment_count);
      Params params = default_params();
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count;
      params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
      params.const_params.round_count = segment_count;
      params.var_params.width = width;
      params.var_params.angle = angle;
      CPoint *data = malloc((size_t) params.const_params.datasize);
      gen_infinity(data, width, angle, segment_count);
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  void change_infinity(Shape* shape, float angle) {
      if ((*shape).params.var_params.angle != angle) {
          (*shape).params.var_params.angle = angle;
          gen_infinity(shape->data, (*shape).params.var_params.width, (*shape).params.var_params.angle, (*shape).params.const_params.round_count);
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glBufferData(GL_ARRAY_BUFFER, shape->params.const_params.datasize, shape->data, GL_DYNAMIC_DRAW);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  static inline void gen_rounded_rectangle_stroked(CPoint* out, CSize size, float radius, float stroke_width, int32_t round_count) {
      int32_t offset = 0;
      float k = (float) (M_PI / 2 / (round_count + 1));
      float inner_radius = radius - stroke_width;
      int32_t i = 0;
      int32_t n = 0;
      for (i = (round_count + 2) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * radius, size.height / 2 - radius + sinf(i * k) * radius);
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * inner_radius, size.height / 2 - radius + sinf(i * k) * inner_radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * radius, size.height / 2 - radius + sinf(i * k) * radius);
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * inner_radius, size.height / 2 - radius + sinf(i * k) * inner_radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * radius, -size.height / 2 + radius + sinf(i * k) * radius);
          out[offset++] = CPointMake(-size.width / 2 + radius + cosf(i * k) * inner_radius, -size.height / 2 + radius + sinf(i * k) * inner_radius);
      }
      n++;
      for (i = (round_count + 1) * n; i <= round_count + 1 + (round_count + 1) * n; i++) {
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * radius, -size.height / 2 + radius + sinf(i * k) * radius);
          out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * inner_radius, -size.height / 2 + radius + sinf(i * k) * inner_radius);
      }
      i = 0;
      out[offset++] = CPointMake(size.width / 2 - radius + cosf(i * k) * radius, size.height / 2 - radius + sinf(i * k) * radius);
      out[offset] = CPointMake(size.width / 2 - radius + cosf(i * k) * inner_radius, size.height / 2 - radius + sinf(i * k) * inner_radius);
  }
  
  Shape create_rounded_rectangle_stroked(CSize size, float radius, float stroke_width, int32_t round_count, const vec4 color) {
      int32_t real_vertex_count = 4 * (2 + round_count) * 2 + 2;
      Params params = default_params();
      params.const_params.round_count = round_count;
      params.const_params.datasize = sizeof(CPoint) * real_vertex_count * 2;
      params.var_params.size = size;
      params.var_params.radius = radius;
      params.var_params.width = stroke_width;
      CPoint *data = (CPoint *) malloc((size_t) params.const_params.datasize);
      gen_rounded_rectangle_stroked(data, params.var_params.size, params.var_params.radius, params.var_params.width, params.const_params.round_count);
      params.const_params.triangle_mode = GL_TRIANGLE_STRIP;
      return (Shape) {{color[0], color[1], color[2], color[3]}, data, create_vbo(params.const_params.datasize, data, GL_DYNAMIC_DRAW), real_vertex_count, params};
  }
  
  void change_rounded_rectangle_stroked(Shape* shape, CSize size, float radius) {
      if ((*shape).params.var_params.size.width != size.width || (*shape).params.var_params.size.height != size.height || (*shape).params.var_params.radius != radius) {
          (*shape).params.var_params.size.width = size.width;
          (*shape).params.var_params.size.height = size.height;
          (*shape).params.var_params.radius = radius;
          gen_rounded_rectangle_stroked((*shape).data, (*shape).params.var_params.size, (*shape).params.var_params.radius, (*shape).params.var_params.width, (*shape).params.const_params.round_count);
          glBindBuffer(GL_ARRAY_BUFFER, shape->buffer);
          glBufferSubData(GL_ARRAY_BUFFER, 0, shape->params.const_params.datasize, shape->data);
          glBindBuffer(GL_ARRAY_BUFFER, 0);
      }
  }
  
  //------------------------------
  
  float t(float start_value, float end_value, float start_time, float duration, timing_type type) {
      if (time > start_time + duration) {
          return end_value;
      }
      if (type == Linear) {
          return start_value + (end_value - start_value) * MINf(duration + start_time, MAXf(.0, (time - start_time))) / duration;
      }
      return start_value + (end_value - start_value) * timing(MINf(duration + start_time, MAXf(.0, (time - start_time))) / duration, type);
  }
  
  float t_reversed(float end_value, float start_value, float start_time, float duration, timing_type type) {
      if (time > start_time + duration) {
          return end_value;
      }
      if (type == Linear) {
          return start_value + (end_value - start_value) * MINf(duration + start_time, MAXf(0.0f, (time - start_time))) / duration;
      }
      return start_value + (end_value - start_value) * timing(MINf(duration + start_time, MAXf(0.0f, (time - start_time))) / duration, type);
  }
  
  float t_local(float start_value, float end_value, float start_time, float duration, timing_type type) {
      if (type == Sin) {
          return start_value + (end_value - start_value) * sinf(MINf(MAXf((time_local - start_time) / duration * (float) M_PI, 0), (float) M_PI));
      }
  
      if (time_local > start_time + duration) {
          return end_value;
      }
  
      if (type == Linear) {
          return start_value + (end_value - start_value) * MINf(duration + start_time, MAXf(.0, (time_local - start_time))) / duration;
      }
      return start_value + (end_value - start_value) * timing(MINf(duration + start_time, MAXf(.0, (time_local - start_time))) / duration, type);
  }
  
  xyz star_create_position(float far) {
      starsFar = 1500;
      int32_t minR = 100;
      int32_t maxR = 1000;
      return xyzMake(signrand() * frand(minR, maxR), signrand() * frand(minR, maxR), far);
  }
  
  xyz star_initial_position(int32_t randZ, int32_t forward) {
      starsFar = 1500;
      int32_t minR = 100;
      int32_t maxR = 1000;
      float z = 0;
      if (forward == 1) {
          if (randZ == 0) {
              z = -starsFar;
          } else {
              z = frand(0, -starsFar);
          }
      }
  
      return xyzMake(signrand() * frand(minR, maxR), signrand() * frand(minR, maxR), z);
  }
  
  void draw_stars() {
      float k = (float) width / (float) height;
  
      set_y_offset_objects(-100 * k * 0);
      for (i = 0; i < starsCount; i++) {
          float stars_scroll_offset = MAXf(0, scroll_offset) * 2;
  
          float transition_speed;
          if (direct == 1) {
              float s = 5;
              transition_speed = s - t(0, s, 0, duration_const + 1 + 0.8f, Linear);
          } else {
              transition_speed = t(-4, 0, 0, duration_const + 1, EaseOut);
          }
  
          float speed = stars_scroll_offset + transition_speed;
          stars[i].position.z += speed;
  
          if (stars[i].position.z > 0 && speed > 0) {
              stars[i].position = star_initial_position(0, 1);
          }
          if (stars[i].position.z < -1500 && speed < 0) {
              stars[i].position = star_initial_position(0, 0);
          }
  
          float inc = scroll_offset * 100;
          stars[i].position.z = stars[i].position.z + inc;
  
          star.params.position = stars[i].position;
          float s = 1 + (-stars[i].position.z) / starsFar * 5;
  
          star.params.scale = xyzMake(s, s, 1);
          float far = starsFar;
          star.params.alpha = (1 - (-stars[i].position.z) / far) * 10.0f;
          star.params.alpha = star.params.alpha * star.params.alpha / 10.0f;
  
  
          draw_textured_shape(&star, stars_matrix, NORMAL);
  
          stars[i].position.z = stars[i].position.z - inc;
      }
  
      set_y_offset_objects(offset_y);
  }
  
  static inline void mat4x4_plain(mat4x4 M, int32_t width, int32_t height) {
      int32_t i, j;
      for (i = 0; i < 4; ++i) {
          for (j = 0; j < 4; ++j) {
              M[i][j] = 0.0f;
          }
      }
  
      M[0][0] = 1;
      M[1][1] = 1;
      M[2][2] = 1;
      M[0][0] = 1;
      M[1][1] = (float) width / (float) height;
      M[2][2] = 1;
      M[3][3] = (float) width / 2.0f;
  }
  
  static inline void mat4x4_stars(mat4x4 m, float y_fov_in_degrees, float aspect, float n, float f, int32_t width, int32_t height) {
      if (height >= width) {
          float k = (float) width / (float) height;
          float q = 1.4f;
          m[0][0] = 1.0f / q;
          m[1][0] = 0.0f;
          m[2][0] = 0.0f;
          m[3][0] = 0.0f;
  
          m[1][0] = 0.0f;
          m[1][1] = k / q;
          m[1][2] = 0.0f;
          m[1][3] = 0.0f;
  
          m[2][0] = 0.0f;
          m[2][1] = 0.0f;
          m[2][2] = 1.0f;
          m[2][3] = -1.25f;
  
          m[3][0] = 0.0f;
          m[3][1] = 0.0f;
          m[3][2] = 0.0f;
          m[3][3] = width * k;
      } else {
          float k = (float) height / (float) width;
          float q = 2.0f;
  
          m[0][0] = 1.0f / q;
          m[1][0] = 0.0f;
          m[2][0] = 0.0f;
          m[3][0] = 0.0f;
  
          m[1][0] = 0.0f;
          m[1][1] = (1.0f / k) / q;
          m[1][2] = 0.0f;
          m[1][3] = 0.0f;
  
          m[2][0] = 0.0f;
          m[2][1] = 0.0f;
          m[2][2] = 1.0f;
          m[2][3] = -1.25f;
  
          m[3][0] = 0.0f;
          m[3][1] = 0.0f;
          m[3][2] = 0.0f;
          m[3][3] = height * k;
      }
      mat4x4_translate_independed(m, 0, -2 * y_offset_absolute / (float) height + 4 * scale_factor / (float) height, 0);
  }
  
  void rglNormalDraw() {
      glDisable(GL_DEPTH_TEST);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glColorMask(1, 1, 1, 1);
      glDepthMask(0);
  }
  
  void rglMaskDraw() {
      glEnable(GL_DEPTH_TEST);
      glDisable(GL_BLEND);
      glDepthMask(1);
      glColorMask(0, 0, 0, 0);
      glDepthFunc(GL_GREATER);
      glClearDepthf(0);
      glClear(GL_DEPTH_BUFFER_BIT);
  }
  
  void rglNormalDrawThroughMask() {
      glColorMask(1, 1, 1, 1);
      glDepthFunc(GL_LESS);
      glDepthMask(0);
  }
  
  void mat4x4_scaled(mat4x4 matrix, float s) {
      mat4x4_identity(matrix);
      mat4x4_scale_aniso(matrix, matrix, s, s, s);
  }
  
  void mat4x4_layer(mat4x4 matrix, LayerParams params, float s, float r) {
      float a = main_matrix[1][1];
      mat4x4 model_matrix;
      mat4x4_identity(model_matrix);
      mat4x4 id;
      mat4x4_identity(id);
      float sc = main_matrix[3][3];
      mat4x4_translate(model_matrix, -params.anchor.x / sc, params.anchor.y / sc * a, params.anchor.z / sc);
      mat4x4 scaled;
      mat4x4_identity(scaled);
      float f = 1.0f;
      mat4x4_scale_aniso(scaled, scaled, params.scale.x * f, params.scale.y * f, params.scale.z * f);
      mat4x4 tmp;
      mat4x4_dup(tmp, model_matrix);
      mat4x4_mul(model_matrix, scaled, tmp);
      mat4x4 rotate;
      mat4x4_dup(rotate, id);
      mat4x4_rotate_Z2(rotate, id, -deg_to_radf(params.rotation));
      mat4x4_dup(tmp, model_matrix);
      mat4x4_mul(model_matrix, rotate, tmp);
      mat4x4_translate_independed(model_matrix, params.position.x / sc, -params.position.y / sc * a, params.position.z / sc);
  
      mat4x4 m;
      mat4x4_mul(m, model_matrix, main_matrix);
  
      m[1][0] /= a;
      m[0][1] *= a;
  
      mat4x4 scale_m;
      mat4x4_scaled(scale_m, s);
      mat4x4_rotate_Z(scale_m, r);
      scale_m[1][0] /= a;
      scale_m[0][1] *= a;
      mat4x4_mul(matrix, scale_m, m);
  }
  
  float bubble_dots_sinf(float a) {
      if (a < M_PI * 2 * anim_bubble_dots_end_period) {
          return sinf(a);
      }
      return 0;
  }
  
  static void reset_ic() {
      anim_smile_start_time1 = time_local;
      anim_pencil_start_time = 0;
      anim_pencil_start_all_end_time = 0;
      anim_cam_next_time = time_local;
      anim_smile_stage = 0;
      anim_smile_blink_one = 0;
      anim_pencil_stage = 0;
      anim_bubble_dots_end_period = 4;
      anim_pencil_period = 1;
  }
  
  static void draw_ic(int32_t type) {
      float rotation;
      float beginTimeK;
      float commonDelay;
      float beginY = 250;
      int32_t bounce;
      texture_program_type COLOR, LIGHT_COLOR;
      if (type == 0) {
          beginTimeK = 2.0f;
          commonDelay = duration_const * 0.5f;
          bounce = 1;
          rotation = -D2R(free_scroll_offset);
          cloud_scroll_offset = 0;
          COLOR = RED, LIGHT_COLOR = LIGHT_RED;
      } else {
          rotation = 0;
          beginTimeK = 2.5;
          commonDelay = 0;
          bounce = 1;
          COLOR = BLUE, LIGHT_COLOR = LIGHT_BLUE;
      }
      float scale;
      float t_y;
      CPoint ic_pos;
      float ic_layer_alpha;
      if (current_page == 1 && direct == 0) {
          ic_layer_alpha = t(1, 0, 0, duration_const * 0.25f, EaseOut);
      } else {
          ic_layer_alpha = 1;
      }
      ic_pin.params.alpha = ic_layer_alpha;
      ic_cam.params.alpha = ic_layer_alpha;
      ic_cam_lens.params.alpha = ic_layer_alpha;
      ic_smile.params.alpha = ic_layer_alpha;
      ic_smile_eye.params.alpha = ic_layer_alpha;
      ic_videocam.params.alpha = ic_layer_alpha;
      ic_bubble.params.alpha = ic_layer_alpha;
      ic_bubble_dot.params.alpha = ic_layer_alpha;
      ic_pencil.params.alpha = ic_layer_alpha;
  
      if (type == 0) {
          ic_pos = CPointMake(-106 / 2, 61 / 2);
          if (current_page == 1 && direct == 0) {
              t_y = 0;
          } else {
              t_y = t(beginY, 0, commonDelay + duration_const * 0.2f * beginTimeK, duration_const, EaseOut);
              float arg = MAXf(0, time - (commonDelay + duration_const * 0.2f * beginTimeK)) * 50;
              float value = beginY * powf(2.71, -0.055f * arg * 2) * cosf(0.08f * arg) * 0.4f;
              t_y -= value * bounce;
          }
      } else {
          ic_pos = CPointMake(-162 / 2 + 4, +26 / 2 + 20);
          t_y = t(beginY, 0, commonDelay + duration_const * 0.2f * beginTimeK, duration_const, EaseOut);
          float value = 0;
          float e = 2.71;
          float arg = MAXf(0, time - (commonDelay + duration_const * 0.2f * beginTimeK)) * 50;
          value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg - (float) M_PI / 8.0f) * 0.4f;
          t_y -= value * bounce;
      }
  
      if (time_local > anim_pin_start_time) {
          if (time_local > anim_pin_start_time + anim_pin_duration) {
              anim_pin_start_time = time_local + duration_const * frand(10, 20) * 2;
              anim_pin_duration = duration_const * frand(10, 20) * 2;
          }
      }
      float pinasin = 0;
      ic_pin_layer.position = xyzMake(ic_pos.x + cosf(time_local * 5) * 3 * pinasin + cloud_scroll_offset, ic_pos.y + sinf(time_local * 5) * 1.5f * pinasin + t_y, 0);
      mat4x4_layer(ic_matrix, ic_pin_layer, 1, rotation);
      draw_textured_shape(&ic_pin, ic_matrix, COLOR);
  
      if (type == 1) {
          ic_videocam_layer.rotation = -30 + t_local(anim_videocam_old_angle, anim_videocam_angle, anim_videocam_start_time, anim_videocam_duration, EaseOut);
          t_y = t(beginY, 0, commonDelay + duration_const * 0.45f * beginTimeK, duration_const, EaseOut);
          float value = 0;
          float e = 2.71;
          float arg = MAXf(0, time - (commonDelay + duration_const * 0.45f * beginTimeK)) * 50;
          value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * 0.4f;
          t_y -= value * bounce;
          if (t_y <= 1 && time_local > anim_videocam_next_time) {
              anim_videocam_duration = duration_const * frand(1.0f, 1.5f) * 1.5f;
              anim_videocam_old_angle = anim_videocam_angle;
              anim_videocam_angle = 15 * irand(-1, 1);
              anim_videocam_start_time = time_local;
              anim_videocam_next_time = time_local + 1000000 + duration_const * frand(5, 8);
          }
          ic_videocam_layer.position = xyzMake(-68 / 2 + cloud_scroll_offset, +80 / 2 + t_y, 0);
          mat4x4_layer(ic_matrix, ic_videocam_layer, 1, rotation);
          draw_textured_shape(&ic_videocam, ic_matrix, COLOR);
      }
  
      if (type == 0) {
          ic_pos = CPointMake(107 / 2, 78 / 2);
          if (current_page == 1 && direct == 0) {
              t_y = 0;
          } else {
              t_y = t(beginY, 0, commonDelay + duration_const * 0.3f * beginTimeK, duration_const, EaseOut);
              float value = 0;
              float e = 2.71;
              float arg = MAXf(0, time - (commonDelay + duration_const * 0.3f * beginTimeK)) * 50;
              value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * 0.4f;
              t_y -= value * bounce;
          }
      } else {
          ic_pos = CPointMake(-28 / 2, -20 / 2 + 2);
          t_y = t(beginY, 0, commonDelay + duration_const * 0.15f * beginTimeK, duration_const, EaseOut);
          float arg = MAXf(0, time - (commonDelay + duration_const * 0.15f * beginTimeK)) * 50;
          float value = beginY * powf(2.71, -0.055f * arg * 2) * cosf(0.08f * arg) * 0.4f;
          t_y -= value * bounce;
      }
  
      if (t_y <= 1 && time_local > anim_cam_next_time) {
          anim_cam_duration = duration_const * frand(1.0, 1.5);
          anim_cam_old_angle = anim_cam_angle;
          anim_cam_old_position = anim_cam_position;
          anim_cam_start_time = time_local;
          anim_cam_next_time = time_local + 10000000;
          int32_t r = irand(0, 1);
          if (r == 0) {
              anim_cam_position = CPointMake(-8 + 4, 0);
              anim_cam_angle = signrand() * 10;
          } else if (r == 1) {
              anim_cam_position = CPointMake(4, -5);
              anim_cam_angle = signrand() * 10;
          } else if (r == 2) {
              anim_cam_position = CPointMake(0, 0);
              anim_cam_angle = 0;
          }
          qShot = irand(1, 2);
          anim_camshot_start_time = time_local + duration_const * 0.5f;
          anim_camshot_duration = duration_const * .4f;
      }
  
      ic_cam_layer.rotation = 15 + t_local(anim_cam_old_angle, anim_cam_angle, anim_cam_start_time, anim_cam_duration, EaseOut);
      ic_cam_layer.position = xyzMake(
              ic_pos.x + 0 * t_local(anim_cam_old_position.x, anim_cam_position.x, anim_cam_start_time, anim_cam_duration, EaseOut) + cloud_scroll_offset,
              ic_pos.y + 0 * t_local(anim_cam_old_position.y, anim_cam_position.y, anim_cam_start_time, anim_cam_duration, EaseOut)
              + t_y,
              0);
  
      mat4x4_layer(ic_matrix, ic_cam_layer, 1, rotation);
      draw_textured_shape(&ic_cam, ic_matrix, COLOR);
  
      float lens_scale;
      lens_scale = 1;
      if (qShot >= 0 && time_local > anim_camshot_start_time) {
          lens_scale = t_local(1, 0, anim_camshot_start_time, anim_camshot_duration, Sin);
          if (time_local > anim_camshot_start_time + anim_camshot_duration) {
              qShot--;
              anim_camshot_start_time = time_local + anim_camshot_duration;
          }
      }
      ic_cam_lens.params.scale = xyzMake(lens_scale, lens_scale, 1);
      ic_cam_lens.params.position = xyzMake(0, 1.7, 0);
      draw_textured_shape(&ic_cam_lens, ic_matrix, COLOR);
  
      if (type == 0) {
          ic_pos = CPointMake(70 / 2, -116 / 2);
          if (current_page == 1 && direct == 0) {
              t_y = 0;
          } else {
              t_y = t(beginY, 0, commonDelay + duration_const * .0f * beginTimeK, duration_const, EaseOut);
              float value = 0;
              float e = 2.71;
              float arg = MAXf(0, time - (commonDelay + duration_const * .0f * beginTimeK)) * 50;
              value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * .4f;
              t_y -= value * bounce;
          }
      } else {
          ic_pos = CPointMake(+60 / 2, 50 / 2);
          t_y = t(beginY, 0, commonDelay + duration_const * 0.25f * beginTimeK, duration_const, EaseOut);
  
          float value = 0;
          float e = 2.71;
          float arg = MAXf(0, time - (commonDelay + duration_const * 0.25f * beginTimeK)) * 50;
          value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg - (float) M_PI / 8.0f) * .4f;
  
          t_y -= value * bounce;
      }
      float smile_laught = 0;
      float anim_smile_fade_duration = duration_const * 2;
      float anim_smile_duration = duration_const * 2;
      if (anim_smile_stage == 0) {
          smile_laught = t_local(0, 1, anim_smile_start_time1, anim_smile_fade_duration, Linear);
          if (time_local > anim_smile_duration * 3 + anim_smile_start_time1) {
              anim_smile_stage = 1;
              anim_smile_start_time2 = time_local;
          }
      }
  
      if (anim_smile_stage == 1) {
          smile_laught = t_local(1, 0, anim_smile_start_time2, anim_smile_fade_duration, Linear);
          if (time_local > anim_smile_duration + anim_smile_start_time2) {
              smile_laught = 0;
              anim_smile_stage = 2;
              anim_smile_blink_one = 1;
              anim_smile_blink_start_time = time_local + duration_const;
          }
      }
  
      float y = 0;
      if (anim_smile_stage < 2) {
          y = sinf(time_local * (float) M_PI * 10) * 1.5f * smile_laught;
      }
  
      ic_smile_layer.position = xyzMake(ic_pos.x + cloud_scroll_offset, y + ic_pos.y + t_y, 0);
      mat4x4_layer(ic_matrix, ic_smile_layer, 1, rotation);
      draw_textured_shape(&ic_smile, ic_matrix, COLOR);
  
      if (time_local > anim_smile_blink_start_time + .1) {
  
          float blink_pause = frand(3, 6);
          if (irand(0, 3) == 0) {
              blink_pause = .3;
          }
          if (anim_smile_blink_one == 1) {
              blink_pause = frand(3, 6);
          }
          anim_smile_blink_start_time = time_local + blink_pause;
  
          anim_smile_blink_one = 0;
      }
  
      int32_t stop_time = 5;
      float eye_scale = t_local(1, 0, anim_smile_blink_start_time, 0.1f, Sin);
      ic_smile_eye.params.scale = xyzMake(1, eye_scale, 1);
      if (time > stop_time) ic_smile_eye.params.scale = xyzMake(1, 1, 1);
  
      ic_smile_eye.params.position = xyzMake(-7, -4.5f, 0);
      draw_textured_shape(&ic_smile_eye, ic_matrix, COLOR);
  
      if (anim_smile_blink_one == 1) ic_smile_eye.params.scale = xyzMake(1, 1, 1);
      if (time > stop_time) ic_smile_eye.params.scale = xyzMake(1, 1, 1);
      ic_smile_eye.params.position = xyzMake(7, -4.5f, 0);
      draw_textured_shape(&ic_smile_eye, ic_matrix, COLOR);
  
      if (type == 0) {
          ic_pos = CPointMake(-60 / 2, 110 / 2);
          if (current_page == 1 && direct == 0) {
              t_y = 0;
          } else {
              t_y = t(beginY, 0, commonDelay + duration_const * .45f * beginTimeK, duration_const, EaseOut);
  
              float value = 0;
              float e = 2.71;
              float arg = MAXf(0, time - (commonDelay + duration_const * .45f * beginTimeK)) * 50;
  
              value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * .4f;
  
              t_y -= value * bounce;
          }
      } else {
          ic_pos = CPointMake(72 / 2, -74 / 2);
          t_y = t(beginY, 0, commonDelay + duration_const * .0f * beginTimeK, duration_const, EaseOut);
          float value = 0;
          float e = 2.71;
          float arg = MAXf(0, time - (commonDelay + duration_const * .0f * beginTimeK)) * 50;
          value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * .4f;
          t_y -= value * bounce;
      }
      ic_bubble_layer.position = xyzMake(ic_pos.x + cloud_scroll_offset, ic_pos.y + t_y, 0);
      mat4x4_layer(ic_matrix, ic_bubble_layer, 1, rotation);
      draw_textured_shape(&ic_bubble, ic_matrix, COLOR);
  
      scale = 0.7f + 0.2f * bubble_dots_sinf(time * 10);
      ic_bubble_dot.params.scale = xyzMake(scale, scale, scale);
      ic_bubble_dot.params.position = xyzMake(0 - 80.5f, -9 / 2.0f, 0);
      draw_textured_shape(&ic_bubble_dot, ic_matrix, LIGHT_COLOR);
  
      scale = 0.7f + 0.2f * bubble_dots_sinf((float) -M_PI * 2 / 3 + time * 10);
      if (anim_bubble_dots_stage == 0) scale = MAXf(.7, scale);
      ic_bubble_dot.params.scale = xyzMake(scale, scale, scale);
      ic_bubble_dot.params.position = xyzMake(0, -9 / 2.0f, 0);
      draw_textured_shape(&ic_bubble_dot, ic_matrix, LIGHT_COLOR);
  
      scale = 0.7f + 0.2f * bubble_dots_sinf((float) -M_PI * 2 / 3 * 2 + time * 10);
      if (anim_bubble_dots_stage == 0) scale = MAXf(.7, scale);
      ic_bubble_dot.params.scale = xyzMake(scale, scale, scale);
      ic_bubble_dot.params.position = xyzMake(0 + 80.5f, -9 / 2.0f, 0);
      draw_textured_shape(&ic_bubble_dot, ic_matrix, LIGHT_COLOR);
  
      if (type == 0) {
          ic_pos = CPointMake(-88 / 2 - 15, -100 / 2 + 13);
          if (current_page == 1 && direct == 0) {
              t_y = 0;
          } else {
              t_y = t(beginY, 0, commonDelay + duration_const * .1f * beginTimeK, duration_const, EaseOut);
              float value = 0;
              float e = 2.71;
              float arg = MAXf(0, time - (commonDelay + duration_const * .1f * beginTimeK)) * 50;
              value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * .4f;
              t_y -= value * bounce;
          }
      } else {
          ic_pos = CPointMake(+152 / 2 - 17, +66 / 2 + 14);
  
          t_y = t(beginY, 0, commonDelay + duration_const * 0.35f * beginTimeK, duration_const, EaseOut);
  
          float value = 0;
          float e = 2.71;
          float arg = MAXf(0, time - (commonDelay + duration_const * 0.35f * beginTimeK)) * 50;
          value = beginY * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg) * 0.4f;
  
          t_y -= value * bounce;
      }
  
      float pencil_x = 0;
      if (anim_pencil_stage == 0) {
          ic_pencil_layer.rotation = t_local(0, -5, anim_pencil_start_all_time, duration_const * 0.5f, EaseOut);
  
          pencil_x = t_local(0, 14, anim_pencil_start_time, 1.5f * 0.85f, Linear);
          if (time_local > anim_pencil_start_time + 1.5 * 0.85) {
              anim_pencil_start_time = time_local;
              anim_pencil_stage = 1;
          }
      } else if (anim_pencil_stage == 1) {
          pencil_x = t_local(14, 0, anim_pencil_start_time, 1.5f * 0.15f, Linear);
          if (time_local > anim_pencil_start_time + 1.5f * 0.15f) {
              if (anim_pencil_period == 0) {
                  anim_pencil_start_all_end_time = time_local;
                  anim_pencil_start_time = time_local + duration_const * 1;
                  anim_pencil_stage = 2;
              } else {
                  anim_pencil_period--;
                  anim_pencil_start_time = time_local;
                  anim_pencil_stage = 0;
              }
          }
      } else if (anim_pencil_stage == 2) {
          ic_pencil_layer.rotation = t_local(-5, 0, anim_pencil_start_all_end_time, duration_const * 0.5f, EaseOut);
          if (time_local > anim_pencil_start_time) {
              anim_pencil_start_all_time = time_local;
              anim_pencil_start_time = time_local;
              anim_pencil_stage = 3;
          }
      }
  
      float pencil_v = (anim_pencil_stage < 2) ? sinf((float) (time_local * 2 * M_PI * 4)) * 0.8f : 0;
      ic_pencil_layer.position = xyzMake(pencil_x + ic_pos.x + cloud_scroll_offset, pencil_v + ic_pos.y + t_y, 0);
      mat4x4_layer(ic_matrix, ic_pencil_layer, 1, rotation);
      draw_textured_shape(&ic_pencil, ic_matrix, COLOR);
  }
  
  void draw_safe(int32_t type, float alpha, float screw_alpha) {
      float screw_distance = 53;
  
      private_screw.params.alpha = alpha * screw_alpha;
  
      scale = 1;
      private_screw.params.scale = xyzMake(scale, scale, 1);
      private_screw.params.position = xyzMake(-screw_distance, -screw_distance, 0);
      draw_textured_shape(&private_screw, private_matrix, NORMAL_ONE);
  
      private_screw.params.scale = xyzMake(scale, scale, 1);
      private_screw.params.position = xyzMake(screw_distance, -screw_distance, 0);
      draw_textured_shape(&private_screw, private_matrix, NORMAL_ONE);
  
      private_screw.params.scale = xyzMake(scale, scale, 1);
      private_screw.params.position = xyzMake(-screw_distance, screw_distance, 0);
      draw_textured_shape(&private_screw, private_matrix, NORMAL_ONE);
  
      private_screw.params.scale = xyzMake(scale, scale, 1);
      private_screw.params.position = xyzMake(screw_distance, screw_distance, 0);
      draw_textured_shape(&private_screw, private_matrix, NORMAL_ONE);
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_onDrawFrame(JNIEnv *env, jclass class) {
      time_local += 0.016f;
  
      if (current_page != prev_page) {
          reset_ic();
          ms0_anim = date;
          fps_anim = 0;
          count_anim_fps = 1;
      }
  
      float knotDelayStep = 0.075f;
      if (prev_page != current_page) {
          for (i = 0; i < 4; i++) {
              knot_delays[i] = (0.65f + knotDelayStep * i) * duration_const;
          }
  
          for (i = 0; i < 10; i++) {
              int32_t j1 = irand(0, 3);
              int32_t j2 = irand(0, 3);
              float temp = knot_delays[j1];
              knot_delays[j1] = knot_delays[j2];
              knot_delays[j2] = temp;
          }
  
          if (current_page == 2) {
              ic_pin_layer.rotation = -15;
              ic_cam_layer.rotation = 15;
              ic_smile_layer.rotation = -15;
              ic_bubble_layer.rotation = -15;
          }
  
          if (current_page == 5) {
              ic_pin_layer.rotation = -15;
              ic_videocam_layer.rotation = -30;
              ic_cam_layer.rotation = 15;
              ic_smile_layer.rotation = -15;
              ic_bubble_layer.rotation = -15;
          }
      }
  
      fps_anim++;
      if (count_anim_fps == 1 && date - ms0_anim >= duration_const) {
          count_anim_fps = 0;
      }
  
      if (date - ms0 >= 1.0f) {
          ms0 = date;
      }
  
      time = date - date0;
  
      float private_back_k = .8;
  
      glClearColor(1, 1, 1, 1);
      glClear(GL_COLOR_BUFFER_BIT);
  
  
      if (current_page == 0) {
          rglNormalDraw();
  
          telegram_sphere.params.alpha = 1;
  
          scale = 1;
  
          float alpha = 1;
          if (direct == 0) {
              alpha = t(0, 1, 0, duration_const, Linear);
  
              fast_body.params.alpha = 1;
              fast_body.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&fast_body, main_matrix, NORMAL);
          }
  
          telegram_sphere.params.alpha = alpha;
          telegram_sphere.params.scale = xyzMake(scale, scale, 1);
  
          telegram_plane.params.alpha = 1;
  
          float tt = MINf(0, (float) (-M_PI * 125. / 180. + time * M_PI * 2 * 1.5));
  
          float dx = sinf(tt) * 75;
          float dy = -sinf(tt) * 60;
  
          telegram_plane.params.position = xyzMake(dx, dy, 0);
  
          float scale = (cosf(tt) + 1) * 0.5f;
  
          telegram_plane.params.scale = xyzMake(cosf(tt) * scale, scale, 1);
  
          if (tt < D2R(125)) {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
          }
      } else if (current_page == 1) {
          rglNormalDraw();
          if (direct == 1) {
              fast_body.params.scale = xyzMake(1, 1, 1);
              fast_body.params.alpha = 1;
              draw_textured_shape(&fast_body, main_matrix, NORMAL);
          } else {
              fast_body.params.alpha = t(0, 1, .0, duration_const, Linear);;
              float scale = t(.95, 1, 0, duration_const, EaseInEaseOut);
              fast_body.params.scale = xyzMake(scale, scale, 1.0f);
              draw_textured_shape(&fast_body, main_matrix, NORMAL);
          }
      } else if (current_page == 2) {
          rglNormalDraw();
          if (direct == 1) {
              fast_body.params.alpha = t(1.0f, .0, .0, duration_const, Linear);;
              float scale = t(1, .95, 0, duration_const, EaseInEaseOut);
              fast_body.params.scale = xyzMake(scale, scale, 1.0f);
              draw_textured_shape(&fast_body, main_matrix, NORMAL);
          }
      } else if (current_page == 4) {
          if (direct == 1) {
              privateLayer.rotation = private_scroll_offset + t(-90, 0, 0, duration_const, EaseOut);
          } else {
              privateLayer.rotation = private_scroll_offset + t(90, 0, 0, duration_const * private_back_k, EaseOut);
          }
          mat4x4_layer(private_matrix, privateLayer, 1.0f, 0);
      }
  
      rglMaskDraw();
      mask1.params.position.z = cloud_extra_mask1.params.position.z = cloud_extra_mask2.params.position.z = cloud_extra_mask3.params.position.z = cloud_extra_mask4.params.position.z = 1;
  
      if (current_page == 0) {
          if (direct == 0) {
              change_rounded_rectangle(&mask1, CSizeMake(r1 * 2, r1 * 2), r1);
              mask1.params.rotation = 0;
          }
      } else if (current_page == 1) {
          if (direct == 1) {
              change_rounded_rectangle(&mask1, CSizeMake(r1 * 2, r1 * 2), r1);
              mask1.params.rotation = 0;
          } else {
              float size = t(r2 * 2, r1 * 2, 0, duration_const, EaseInEaseOut);
              float round = t(30, r1, 0, duration_const, EaseInEaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              free_scroll_offset = 0;
              mask1.params.rotation = t(180, 0.0f, 0, duration_const, EaseInEaseOut) + free_scroll_offset;
          }
      } else if (current_page == 2) {
          if (direct == 1) {
              float size = t(r1 * 2, r2 * 2, 0, duration_const, EaseInEaseOut);
              float round = t(r1, 30, 0, duration_const, EaseInEaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              free_scroll_offset = scroll_offset * 5;
              mask1.params.rotation = t(0, 180.0f, 0, duration_const, EaseInEaseOut) + free_scroll_offset;
          } else {
              free_scroll_offset = scroll_offset * 5;
              float r = 316 / 4.0f;
              float size = t_reversed(r2 * 2, r * 2, 0, duration_const, EaseInEaseOut);
              float round = t_reversed(30, 20, 0, duration_const, EaseInEaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              mask1.params.rotation = t_reversed(180.0f + free_scroll_offset, 180.0f + 90.0f, 0, duration_const, EaseInEaseOut);
          }
      } else if (current_page == 3) {
          if (direct == 1) {
              float r = 316 / 4.0f;
              float size = t(r2 * 2, r * 2, 0, duration_const, EaseInEaseOut);
              float round = t(30, 20, 0, duration_const, EaseInEaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              mask1.params.rotation = t(180.0f + free_scroll_offset, 180.0f + 90.0f, 0, duration_const, EaseInEaseOut);
          } else {
              float r = 316 / 4.0f;
              float size = t_reversed(r * 2, r2 * 2, 0, duration_const, EaseOut);
              float round = t_reversed(20, 30, 0, duration_const, EaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              mask1.params.rotation = t_reversed(180.0f + 90.0f, 180.0f + 90.0f + 90.0f, 0, duration_const, EaseOut);
              mask1.params.position = xyzMake(0, 0, mask1.params.position.z);
          }
      } else if (current_page == 4) {
          if (direct == 1) {
              float r = 316 / 4.0f;
              float size = t(r * 2, r2 * 2, 0, duration_const, EaseOut);
              float round = t(20, 30, 0, duration_const, EaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(size, size), round);
              mask1.params.rotation = private_scroll_offset + t(180.0f + 90.0f, 180.0f + 90.0f + 90.0f, 0, duration_const, EaseOut);
              mask1.params.position = xyzMake(0, 0, mask1.params.position.z);
          } else {
              float k = 0;
              k = 1.0f * private_back_k;
              float scale = t_reversed(r2 * 2, 100, 0, duration_const * k, EaseOut);
              change_rounded_rectangle(&mask1, CSizeMake(scale, scale), t_reversed(30, 50, 0, duration_const * k, EaseOut));
              mask1.params.position = xyzMake(t_reversed(0, 29 / 2, 0, duration_const * k, EaseOut), t_reversed(0, -19 / 2, 0, duration_const * k, EaseOut), mask1.params.position.z);
              mask1.params.rotation = private_scroll_offset + t_reversed(180.0f + 90.0f + 90.0f, 180.0f + 90.0f + 90.0f + 90.0f, 0, duration_const * k, EaseOut);
  
              k = 1.0f * private_back_k;
              int32_t sublayer2_radius = 33;
              cloud_extra_mask1.params.position = xyzMake(t_reversed(0, -122 / 2, 0, duration_const * k, EaseOut), t_reversed(0, 54 / 2 - 1, 0, duration_const * k, EaseOut), cloud_extra_mask1.params.position.z);
              scale = t_reversed(0, sublayer2_radius, 0, duration_const * k, EaseOut);
              cloud_extra_mask1.params.scale = xyzMake(scale, scale, 1);
              draw_shape(&cloud_extra_mask1, main_matrix);
  
              k = 1.15f * private_back_k;
              int32_t sublayer3_radius = 94 / 4;
              cloud_extra_mask2.params.position = xyzMake(t_reversed(0, -84 / 2, 0, duration_const * k, EaseOut), t_reversed(0, -29 / 2, 0, duration_const * k, EaseOut), cloud_extra_mask2.params.position.z);
              scale = t_reversed(0, sublayer3_radius, 0, duration_const * k, EaseOut);
              cloud_extra_mask2.params.scale = xyzMake(scale, scale, 1);
              draw_shape(&cloud_extra_mask2, main_matrix);
  
              k = 1.3f * private_back_k;
              int32_t sublayer4_radius = 124 / 4;
              cloud_extra_mask3.params.position = xyzMake(t_reversed(0, 128 / 2, 0, duration_const * k, EaseOut), t_reversed(0, 56 / 2, 0, duration_const * k, EaseOut), cloud_extra_mask3.params.position.z);
              scale = t_reversed(0, sublayer4_radius, 0, duration_const * k, EaseOut);
              cloud_extra_mask3.params.scale = xyzMake(scale, scale, 1);
              draw_shape(&cloud_extra_mask3, main_matrix);
  
              k = 1.5f * private_back_k;
              int32_t sublayer5_radius = 64;
              cloud_extra_mask4.params.position = xyzMake(t_reversed(0, 0, 0, duration_const * k, EaseOut), t_reversed(0, 50, 0, duration_const * k, EaseOut), cloud_extra_mask4.params.position.z);
              scale = t_reversed(0, sublayer5_radius, 0, duration_const * k, EaseOut);
              cloud_extra_mask4.params.scale = xyzMake(scale, scale, 1);
              draw_shape(&cloud_extra_mask4, main_matrix);
          }
      } else if (current_page == 5) {
          float k = 0.8f;
          float scale = t(r2 * 2, 100, 0, duration_const * k, EaseOut);
          change_rounded_rectangle(&mask1, CSizeMake(scale, scale), t(30, 50, 0, duration_const * k, EaseOut));
          mask1.params.position = xyzMake(t(0, 29 / 2, 0, duration_const * k, EaseOut), t(0, -19 / 2, 0, duration_const * k, EaseOut), mask1.params.position.z);
          mask1.params.rotation = t(180.0f + 90.0f + 90.0f, 180.0f + 90.0f + 90.0f + 90.0f, 0, duration_const * k, EaseOut);
  
          k = 1.0f;
          int32_t sublayer2_radius = 33;
          cloud_extra_mask1.params.position = xyzMake(t(0, -122 / 2, 0, duration_const * k, EaseOut), t(0, 54 / 2 - 1, 0, duration_const * k, EaseOut), cloud_extra_mask1.params.position.z);
          scale = t(0, sublayer2_radius, 0, duration_const * k, EaseOut);
          cloud_extra_mask1.params.scale = xyzMake(scale, scale, 1);
          draw_shape(&cloud_extra_mask1, main_matrix);
  
  
          k = 1.15;
          int32_t sublayer3_radius = 94 / 4;
          cloud_extra_mask2.params.position = xyzMake(t(0, -84 / 2, 0, duration_const * k, EaseOut), t(0, -29 / 2, 0, duration_const * k, EaseOut), cloud_extra_mask2.params.position.z);
          scale = t(0, sublayer3_radius, 0, duration_const * k, EaseOut);
          cloud_extra_mask2.params.scale = xyzMake(scale, scale, 1);
          draw_shape(&cloud_extra_mask2, main_matrix);
  
  
          k = 1.3;
          int32_t sublayer4_radius = 124 / 4;
          cloud_extra_mask3.params.position = xyzMake(t(0, 128 / 2, 0, duration_const * k, EaseOut), t(0, 56 / 2, 0, duration_const * k, EaseOut), cloud_extra_mask3.params.position.z);
          scale = t(0, sublayer4_radius, 0, duration_const * k, EaseOut);
          cloud_extra_mask3.params.scale = xyzMake(scale, scale, 1);
          draw_shape(&cloud_extra_mask3, main_matrix);
  
  
          k = 1.5f;
          int32_t sublayer5_radius = 64;
          cloud_extra_mask4.params.position = xyzMake(t(0, 0, 0, duration_const * k, EaseOut), t(0, 50, 0, duration_const * k, EaseOut), cloud_extra_mask4.params.position.z);
          scale = t(0, sublayer5_radius, 0, duration_const * k, EaseOut);
          cloud_extra_mask4.params.scale = xyzMake(scale, scale, 1);
          draw_shape(&cloud_extra_mask4, main_matrix);
  
      }
      draw_shape(&mask1, main_matrix);
  
      int32_t rr = 30;
      int32_t seg = 15;
      int32_t ang = 180;
      rglNormalDrawThroughMask();
      if (current_page == 0) {
          if (direct == 0) {
              glEnable(GL_BLEND);
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
              change_segmented_square(&spiral, r1, D2R(rr + seg), D2R(speedometer_scroll_offset + calculated_speedometer_sin + t(-seg + ang, 0, 0, duration_const, EaseOut)));
  
              spiral.params.scale = xyzMake(1, 1, 1);
              spiral.params.rotation = t(180.0f, 0, 0, duration_const, EaseOut);
              spiral.params.alpha = t(1, 0, 0, duration_const, Linear);
              draw_textured_shape(&spiral, main_matrix, NORMAL_ONE);
  
              fast_arrow.params.alpha = fast_arrow_shadow.params.alpha = t(1, 0, 0, duration_const, Linear);
              fast_arrow.params.rotation = fast_arrow_shadow.params.rotation = t(rr, rr - 180 - 160, 0, duration_const, EaseOut) + speedometer_scroll_offset + calculated_speedometer_sin;
              draw_textured_shape(&fast_arrow_shadow, main_matrix, NORMAL_ONE);
              draw_textured_shape(&fast_arrow, main_matrix, NORMAL_ONE);
          }
      } else if (current_page == 1) {
          glEnable(GL_BLEND);
          glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
          speedometer_scroll_offset = scroll_offset * 25;
          calculated_speedometer_sin = 0;
  
          if (direct == 1) {
  
              float value = 0;
              float e = 2.71;
  
              float arg = time * 50;
  
              value = 180 - 180 * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg * 3);
  
              float ta = t(0, 180.0f, 0, duration_const, EaseOut);
  
              change_segmented_square(&spiral, r1, D2R(rr + seg), D2R(-seg + value + speedometer_scroll_offset));
  
              spiral.params.scale = xyzMake(1, 1, 1);
              spiral.params.rotation = ta;
              spiral.params.alpha = t(0, 1, 0, duration_const, Linear);
              draw_textured_shape(&spiral, main_matrix, NORMAL_ONE);
  
              fast_arrow.params.alpha = fast_arrow_shadow.params.alpha = t(0, 1, 0, duration_const, Linear);
              fast_arrow.params.rotation = fast_arrow_shadow.params.rotation = -330 + value + ta + speedometer_scroll_offset;
              draw_textured_shape(&fast_arrow_shadow, main_matrix, NORMAL_ONE);
              draw_textured_shape(&fast_arrow, main_matrix, NORMAL_ONE);
  
          } else {
              spiral.params.alpha = fast_arrow.params.alpha = fast_arrow_shadow.params.alpha = 1;
  
              float value = 0;
              float e = 2.71;
  
              float arg = time * 50;
  
              float dangle = 90;
              value = 180 - 90 - (180 - 90) * powf(e, -0.055f * arg * 2) * cosf(0.08f * arg * 3);
              value *= -1;
  
              change_segmented_square(&spiral, r1, D2R(rr + seg), D2R(speedometer_scroll_offset + value + calculated_speedometer_sin + t(360, 360 - dangle - seg, 0, duration_const, EaseInEaseOut)));
  
              float scale = t(1.18, 1, 0, duration_const, EaseInEaseOut);
              spiral.params.scale = xyzMake(scale, scale, 1);
              spiral.params.rotation = t(360, 180, 0, duration_const, EaseInEaseOut);
              draw_textured_shape(&spiral, main_matrix, NORMAL);
  
              fast_arrow.params.rotation = fast_arrow_shadow.params.rotation = speedometer_scroll_offset + value + calculated_speedometer_sin + t(rr + 360 + 6, rr + 360 - 180 - dangle, 0, duration_const, EaseInEaseOut);
              draw_textured_shape(&fast_arrow_shadow, main_matrix, NORMAL);
              draw_textured_shape(&fast_arrow, main_matrix, NORMAL);
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              free_bg.params.alpha = t(1, 0, 0, duration_const, Linear);
              draw_shape(&free_bg, main_matrix);
  
              draw_ic(0);
          }
      } else if (current_page == 2) {
  
          glEnable(GL_BLEND);
          glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
          if (direct == 1) {
              spiral.params.alpha = fast_arrow.params.alpha = fast_arrow_shadow.params.alpha = 1;
  
              change_segmented_square(&spiral, r1, D2R(rr + seg + speedometer_scroll_offset), D2R(t(-seg + ang, 360, 0, duration_const, EaseInEaseOut)));
  
              float scale = t(1, 1.18, 0, duration_const, EaseInEaseOut);
              spiral.params.scale = xyzMake(scale, scale, 1);
              spiral.params.rotation = t(180, 360, 0, duration_const, EaseInEaseOut);
              draw_textured_shape(&spiral, main_matrix, NORMAL);
  
              fast_arrow.params.rotation = fast_arrow_shadow.params.rotation = speedometer_scroll_offset + t(rr, rr + 360 + 6, 0, duration_const, EaseInEaseOut);
              draw_textured_shape(&fast_arrow_shadow, main_matrix, NORMAL);
              draw_textured_shape(&fast_arrow, main_matrix, NORMAL);
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              free_bg.params.alpha = t(0, 1, 0, duration_const, Linear);
              draw_shape(&free_bg, main_matrix);
  
              draw_ic(0);
          } else {
              glDisable(GL_BLEND);
              free_bg.params.alpha = 1;
              draw_shape(&free_bg, main_matrix);
  
              glEnable(GL_BLEND);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              draw_ic(0);
  
              powerful_bg.params.alpha = t_reversed(0, 1, 0, duration_const, Linear);
              draw_shape(&powerful_bg, main_matrix);
          }
          ribbon1.params.rotation = 0;
          ribbon2.params.rotation = 90;
          ribbon3.params.rotation = 180;
          ribbon4.params.rotation = 270;
      } else if (current_page == 3) {
          if (direct == 1) {
              glDisable(GL_BLEND);
              free_bg.params.alpha = 1;
              draw_shape(&free_bg, main_matrix);
  
              glEnable(GL_BLEND);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              powerful_bg.params.alpha = t(0, 1, 0, duration_const, Linear);
              draw_shape(&powerful_bg, main_matrix);
  
              draw_stars();
  
          } else {
              glDisable(GL_BLEND);
              private_bg.params.alpha = 1;
              draw_shape(&private_bg, main_matrix);
  
              float a = t(0, 1.0f, 0, duration_const, EaseOut);
  
              glEnable(GL_BLEND);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              powerful_bg.params.rotation = 0;
              powerful_bg.params.alpha = a;
              draw_shape(&powerful_bg, main_matrix);
  
              draw_stars();
          }
      } else if (current_page == 4) {
          if (direct == 1) {
  
              glDisable(GL_BLEND);
              powerful_bg.params.alpha = 1;
              draw_shape(&powerful_bg, main_matrix);
  
              float a = t(0, 1.0f, 0, duration_const, EaseOut);
  
              glEnable(GL_BLEND);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              private_bg.params.rotation = t(45, 0, 0, duration_const, EaseOut);
              private_bg.params.alpha = a;
              draw_shape(&private_bg, main_matrix);
  
          } else {
              glDisable(GL_BLEND);
              cloud_bg.params.alpha = 1;
              draw_shape(&cloud_bg, main_matrix);
  
              float a = t(0, 1.0f, 0, duration_const * private_back_k, EaseOut);
  
              glEnable(GL_BLEND);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              private_bg.params.alpha = a;
              draw_shape(&private_bg, main_matrix);
          }
      } else if (current_page == 5) {
          glDisable(GL_BLEND);
          private_bg.params.alpha = 1.0f;
          draw_shape(&private_bg, main_matrix);
          float a = t(0, 1.0f, 0, duration_const, EaseOut);
  
          glEnable(GL_BLEND);
          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
          cloud_bg.params.alpha = a;
          draw_shape(&cloud_bg, main_matrix);
          if (scroll_offset > 0) {
              cloud_scroll_offset = -scroll_offset * 40;
          } else {
              cloud_scroll_offset = -scroll_offset * 15;
          }
          draw_ic(1);
      }
  
      if (current_page == 0) {
          rglNormalDraw();
          if (direct == 0) {
              telegram_sphere.params.alpha = t(0, 1, 0, duration_const * 0.8f, Linear);
              scale = 1;
  
              telegram_sphere.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&telegram_sphere, main_matrix, NORMAL);
  
              float tt = MINf(0, (float) (-M_PI * 125.0f / 180.0f + time * M_PI * 2 * 1.5f));
              float dx = sinf(tt) * 75;
              float dy = -sinf(tt) * 60;
              telegram_plane.params.position = xyzMake(dx, dy, 0);
              float scale = (cosf(tt) + 1) * 0.5f;
              telegram_plane.params.scale = xyzMake(cosf(tt) * scale, scale, 1);
  
              if (tt < D2R(125)) {
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                  draw_textured_shape(&telegram_plane, main_matrix, NORMAL_ONE);
              }
          }
      } else if (current_page == 1) {
          rglNormalDraw();
          if (direct == 1) {
              telegram_sphere.params.alpha = t(1, 0, 0, duration_const, Linear);
              draw_textured_shape(&telegram_sphere, main_matrix, NORMAL);
  
              double tt = time * M_PI * 2 * 1.5f;
  
              float dx = (float) sin(tt) * 75;
              float dy = (float) -sin(tt) * 60;
  
              telegram_plane.params.position = xyzMake(dx, dy, 0);
  
              float scale = (float) (cos(tt) + 1) * 0.5f;
  
              telegram_plane.params.scale = xyzMake((float) cos(tt) * scale, scale, 1);
  
              if (tt < D2R(125)) {
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                  draw_textured_shape(&telegram_plane, main_matrix, NORMAL_ONE);
              }
          }
      } else if (current_page == 2) {
          rglNormalDraw();
  
          float dribbon = 87;
  
          if (direct == 1) {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
              ribbonLayer.rotation = scroll_offset * 5 + t(180, 360, 0, duration_const, EaseInEaseOut);
              mat4x4_layer(ribbons_layer, ribbonLayer, 1.0f, 0);
  
              float scale;
              float dur = duration_const * 0.5f;
  
              free_knot1.params.position = xyzMake(5, -5 - 9, 0);
              scale = t(0, 1, knot_delays[0], dur, EaseOut);
              free_knot1.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&free_knot1, ribbons_layer, NORMAL_ONE);
  
              free_knot2.params.position = xyzMake(-5, -5 - 9, 0);
              scale = t(0, 1, knot_delays[1], dur, EaseOut);
              free_knot2.params.scale = xyzMake(-scale, scale, 1);
              draw_textured_shape(&free_knot2, ribbons_layer, NORMAL_ONE);
  
              free_knot3.params.position = xyzMake(-5, 5 - 9, 0);
              scale = t(0, 1, knot_delays[2], dur, EaseOut);
              free_knot3.params.scale = xyzMake(-scale, scale, 1);
              draw_textured_shape(&free_knot3, ribbons_layer, NORMAL_ONE);
  
              free_knot3.params.position = xyzMake(5, 5 - 9, 0);
              scale = t(0, 1, knot_delays[3], dur, EaseOut);
              free_knot3.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&free_knot3, ribbons_layer, NORMAL_ONE);
  
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              ribbon1.params.alpha = ribbon2.params.alpha = ribbon3.params.alpha = ribbon4.params.alpha = t(0, 1, 0, dur, EaseInEaseOut);
  
              int32_t ribbon_k = time > duration_const ? 1 : 0;
  
              change_ribbon(&ribbon1, ribbonLength - 8.0f * ribbon_k - free_scroll_offset / 5.0f * (30 - 8 * ribbon_k));
              ribbon1.params.position.x = scroll_offset * 30 * 0 + t(-dribbon, 0, 0, duration_const, EaseInEaseOut);
              draw_shape(&ribbon1, ribbons_layer);
  
              change_ribbon(&ribbon2, ribbonLength - 10.0f * ribbon_k - free_scroll_offset / 5.0f * (22 - 10 * ribbon_k));
              ribbon2.params.position.y = scroll_offset * 15 + t(-9 - dribbon, -9, 0, duration_const, EaseInEaseOut);
              draw_shape(&ribbon2, ribbons_layer);
  
              ribbon3.params.position.x = t(dribbon, 0, 0, duration_const, EaseInEaseOut);;
              draw_shape(&ribbon3, ribbons_layer);
  
              ribbon4.params.position.y = t(-9 + dribbon, -9, 0, duration_const, EaseInEaseOut);;
              draw_shape(&ribbon4, ribbons_layer);
  
              ribbonLayer.anchor.y = 0;
              ribbonLayer.position.y = 0;
  
              change_ribbon(&ribbon1, ribbonLength);
              change_ribbon(&ribbon2, ribbonLength);
              change_ribbon(&ribbon3, ribbonLength);
              change_ribbon(&ribbon4, ribbonLength);
          } else {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
              float scale = t(1, 2, 0, duration_const, EaseIn);
              powerful_mask.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&powerful_mask, main_matrix, NORMAL_ONE);
  
  
              ribbonLayer.rotation = free_scroll_offset + t_reversed(360, 360 + (45 + 30), 0, duration_const, EaseOut);
              ribbonLayer.position.y = t_reversed(0, -8, 0, duration_const * 0.8f, EaseOut);
              ribbonLayer.anchor.y = t_reversed(0, -9, 0, duration_const * 0.8f, EaseOut);
              mat4x4_layer(ribbons_layer, ribbonLayer, 1.0f, 0);
  
  
              float dur = duration_const * 0.5f;
  
              free_knot1.params.position = xyzMake(11 / 2, -11 / 2 - 9, 0);
              scale = t(0, 1, knot_delays[0], dur, EaseOut);
              free_knot1.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&free_knot1, ribbons_layer, NORMAL_ONE);
  
              free_knot2.params.position = xyzMake(-11 / 2, -11 / 2 - 9, 0);
              scale = t(0, 1, knot_delays[1], dur, EaseOut);
              free_knot2.params.scale = xyzMake(-scale, scale, 1);
              draw_textured_shape(&free_knot2, ribbons_layer, NORMAL_ONE);
  
              free_knot3.params.position = xyzMake(-11 / 2, 11 / 2 - 9, 0);
              scale = t(0, 1, knot_delays[2], dur, EaseOut);
              free_knot3.params.scale = xyzMake(-scale, scale, 1);
              draw_textured_shape(&free_knot3, ribbons_layer, NORMAL_ONE);
  
              free_knot3.params.position = xyzMake(11 / 2, 11 / 2 - 9, 0);
              scale = t(0, 1, knot_delays[3], dur, EaseOut);
              free_knot3.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&free_knot3, ribbons_layer, NORMAL_ONE);
  
              float a1 = -25;
              ribbon1.params.rotation = t_reversed(0, a1, 0, duration_const, EaseOut);
              ribbon3.params.rotation = t_reversed(180, 180 + a1, 0, duration_const, EaseOut);
  
              float a2 = 0;
              ribbon2.params.rotation = t_reversed(90, 90 + a2, 0, duration_const, EaseOut);
              ribbon4.params.rotation = t_reversed(270, 270 + a2, 0, duration_const, EaseOut);
  
              float k = 0.9f;
              ribbon2.params.alpha = ribbon4.params.alpha = t_reversed(1, 0, duration_const * 0.5f, duration_const * 0.1f, Linear);
  
              int32_t ribbon_k = 0;
              change_ribbon(&ribbon1, t_reversed(ribbonLength - 8.0f * ribbon_k, 0, 0, duration_const * 0.9f, Linear) - free_scroll_offset / 5.0f * (30 - 8 * ribbon_k));
              ribbon1.params.position.x = 0;
              draw_shape(&ribbon1, ribbons_layer);
  
              change_ribbon(&ribbon2, t_reversed(ribbonLength - 10.0f * ribbon_k, 0, 0, duration_const * k, Linear) - free_scroll_offset / 5.0f * (22 - 10 * ribbon_k));
              ribbon2.params.position.y = scroll_offset * 15 + -9;
              draw_shape(&ribbon2, ribbons_layer);
  
              change_ribbon(&ribbon3, t_reversed(ribbonLength, 0, 0, duration_const * 0.9f, Linear));
              draw_shape(&ribbon3, ribbons_layer);
  
              change_ribbon(&ribbon4, t_reversed(ribbonLength, 0, duration_const * 0.6f * 0, duration_const * k, Linear));
              draw_shape(&ribbon4, ribbons_layer);
  
              float infinityDurK = 1.3;
  
              rglMaskDraw();
  
              change_infinity(&infinity, t_reversed(0, 0.99, 0, duration_const * infinityDurK, EaseOut));
  
              float rot1 = t(0, -50, duration_const * 0.5f, duration_const * 0.8f, EaseOut);
              float rot2 = t(0, -30, duration_const * 0.8f, duration_const, EaseOut);
              infinity.params.rotation = rot1;
  
              infinity.params.position.z = 1;
              infinity.params.position.y = -6;
              infinity.params.anchor = xyzMake(52.75, 23.5f, 0);
  
              float infinity_scale = 1.025;
              infinity.params.scale = xyzMake(infinity_scale, infinity_scale, 1);
              draw_shape(&infinity, main_matrix);
              infinity.params.scale = xyzMake(-infinity_scale, -infinity_scale, 1);
              draw_shape(&infinity, main_matrix);
              rglNormalDrawThroughMask();
              glEnable(GL_BLEND);
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              powerful_infinity_white.params.rotation = rot1 + rot2;
              powerful_infinity_white.params.alpha = 1;
              powerful_infinity_white.params.position.y = -6;
              draw_textured_shape(&powerful_infinity_white, main_matrix, NORMAL_ONE);
          }
      } else if (current_page == 3) {
          if (direct == 1) {
              ribbon1.params.position.x = 0;
              ribbon2.params.position.y = -9;
              ribbon3.params.position.x = 0;
              ribbon4.params.position.y = -9;
              rglNormalDraw();
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              float scale = t(2, 1, 0, duration_const, EaseOut);
              powerful_mask.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&powerful_mask, main_matrix, NORMAL_ONE);
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              ribbonLayer.rotation = free_scroll_offset + t(360, 360 + (45 + 30), 0, duration_const * 0.8f, EaseOut);
              ribbonLayer.position.y = t(0, -8, 0, duration_const * 0.8f, EaseOut);
              ribbonLayer.anchor.y = t(0, -9, 0, duration_const * 0.8f, EaseOut);
              mat4x4_layer(ribbons_layer, ribbonLayer, 1.0f, 0);
  
              float a1 = -25;
              ribbon1.params.rotation = t(0, a1, 0, duration_const, EaseOut);
              ribbon3.params.rotation = t(180, 180 + a1, 0, duration_const, EaseOut);
  
              float a2 = 0;
              ribbon2.params.rotation = t(90, 90 + a2, 0, duration_const, EaseOut);
              ribbon4.params.rotation = t(270, 270 + a2, 0, duration_const, EaseOut);
  
              float k = 0.5f;
              ribbon2.params.alpha = ribbon4.params.alpha = t(1, 0, duration_const * k * 0.5f, duration_const * k * 0.1f, Linear);
  
              int32_t ribbon_k = time > duration_const ? 1 : 0;
  
              change_ribbon(&ribbon1, t(ribbonLength - 8.0f * ribbon_k - free_scroll_offset / 5.0f * (30 - 8 * ribbon_k), 0, 0, duration_const * 0.9f, Linear));
              draw_shape(&ribbon1, ribbons_layer);
  
              change_ribbon(&ribbon2, t(ribbonLength - 10.0f * ribbon_k - free_scroll_offset / 5.0f * (22 - 10 * ribbon_k), 0, 0, duration_const * k, Linear));
              draw_shape(&ribbon2, ribbons_layer);
  
              change_ribbon(&ribbon3, t(ribbonLength, 0, 0, duration_const * 0.9f, Linear));
              draw_shape(&ribbon3, ribbons_layer);
  
              change_ribbon(&ribbon4, t(ribbonLength, 0, 0, duration_const * k, Linear));
              draw_shape(&ribbon4, ribbons_layer);
  
              float infinityDurK = 1.1f;
              if (time < duration_const * infinityDurK - 0.025f) {
                  rglMaskDraw();
  
                  change_infinity(&infinity, t(0, 0.99f, 0, duration_const * infinityDurK, Linear));
  
                  infinity.params.rotation = 0;
  
                  infinity.params.position.z = 1;
                  infinity.params.position.y = -6;
                  infinity.params.anchor = xyzMake(52.75, 23.5f, 0);
  
                  float infinity_scale = 1.025f;
                  infinity.params.scale = xyzMake(infinity_scale, infinity_scale, 1);
                  draw_shape(&infinity, main_matrix);
  
                  infinity.params.scale = xyzMake(-infinity_scale, -infinity_scale, 1);
                  draw_shape(&infinity, main_matrix);
  
                  rglNormalDrawThroughMask();
                  glEnable(GL_BLEND);
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
                  powerful_infinity_white.params.rotation = 0;
                  powerful_infinity_white.params.alpha = 1;
                  powerful_infinity_white.params.position.y = -6;
  
                  draw_textured_shape(&powerful_infinity_white, main_matrix, NORMAL_ONE);
              } else {
                  rglNormalDraw();
  
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                  powerful_infinity.params.position.y = -6;
                  powerful_infinity.params.alpha = 1;
                  draw_textured_shape(&powerful_infinity, main_matrix, NORMAL_ONE);
              }
          } else {
              rglNormalDraw();
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
              float scale = t(2, 1, 0, duration_const, EaseOut);
              powerful_mask.params.scale = xyzMake(scale, scale, 1);
              draw_textured_shape(&powerful_mask, main_matrix, NORMAL_ONE);
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              scale = t(1, 2, 0, duration_const, EaseOut);
              private_stroke.params.scale = xyzMake(scale, scale, 1);
              private_stroke.params.rotation = t(0, -90, 0, duration_const, EaseOut);
              private_stroke.params.alpha = t(1, 0, 0, duration_const, Linear);
              private_stroke.params.position = xyzMake(0, t(0, -6, 0, duration_const, EaseOut), 0);
              scale = t_reversed(63 * 2.0f, 63 * 2, 0, duration_const, EaseOut);
              change_rounded_rectangle_stroked(&private_stroke, CSizeMake(scale, scale), scale / 2.0f);
              draw_shape(&private_stroke, main_matrix);
  
              float infinityDurK = 1.1;
              if (time < duration_const * infinityDurK - 0.025f) {
                  rglMaskDraw();
  
                  change_infinity(&infinity, t(0, 0.99, 0, duration_const * infinityDurK, Linear));
  
                  infinity.params.rotation = 0;
  
                  infinity.params.position.z = 1;
                  infinity.params.position.y = -6;
                  infinity.params.anchor = xyzMake(52.75, 23.5f, 0);
  
                  float infinity_scale = 1.025;
                  infinity.params.scale = xyzMake(infinity_scale, infinity_scale, 1);
                  draw_shape(&infinity, main_matrix);
  
                  infinity.params.scale = xyzMake(-infinity_scale, -infinity_scale, 1);
                  draw_shape(&infinity, main_matrix);
  
  
                  rglNormalDrawThroughMask();
                  glEnable(GL_BLEND);
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
                  powerful_infinity_white.params.rotation = 0;
                  powerful_infinity_white.params.alpha = 1;
                  powerful_infinity_white.params.position.y = -6;
  
                  draw_textured_shape(&powerful_infinity_white, main_matrix, NORMAL_ONE);
              } else {
                  rglNormalDraw();
  
                  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                  powerful_infinity.params.position.y = -6;
                  powerful_infinity.params.alpha = 1;
                  draw_textured_shape(&powerful_infinity, main_matrix, NORMAL_ONE);
              }
          }
      } else if (current_page == 4) {
          private_stroke.params.scale = xyzMake(1, 1, 1);
  
          private_scroll_offset = scroll_offset * 5;
  
          rglNormalDraw();
          glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
  
          scale = t(1, 2, 0, duration_const, EaseOut);
          if (scale < 1.5) {
              powerful_mask.params.scale = xyzMake(scale, scale, 1);
          }
  
          if (direct == 1) {
              privateLayer.rotation = private_scroll_offset + t(-90, 0, 0, duration_const, EaseOut);
          } else {
              privateLayer.rotation = private_scroll_offset + t(90, 0, 0, duration_const * private_back_k, EaseOut);
          }
  
          mat4x4_layer(private_matrix, privateLayer, 1, 0);
  
          if (direct == 1) {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              powerful_infinity.params.position.y = -6;
              powerful_infinity.params.alpha = t(1, 0, 0, duration_const * 0.25f, EaseIn);
              draw_textured_shape(&powerful_infinity, main_matrix, NORMAL_ONE);
          }
  
          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  
          if (direct == 1) {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              scale = t(0.5f, 1.0f, 0, duration_const, EaseOut);
              private_door.params.scale = xyzMake(scale, scale, 1);
              private_door.params.alpha = t(.0, 1.0f, 0, duration_const, EaseOut);
              draw_textured_shape(&private_door, main_matrix, NORMAL_ONE);
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              private_stroke.params.rotation = private_scroll_offset;
              private_stroke.params.alpha = 1;
              private_stroke.params.position = xyzMake(0, 0, 0);
              scale = t(63, 63 * 2, 0, duration_const, EaseOut);
              change_rounded_rectangle_stroked(&private_stroke, CSizeMake(scale, scale), scale / 2.0f);
              draw_shape(&private_stroke, main_matrix);
  
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              float k = .0;
              scale = t(0.5f, 1.0f, duration_const * k, duration_const, EaseOut);
              private_keyhole_body.params.rotation = private_scroll_offset;
              private_keyhole_body.params.scale = xyzMake(scale, scale, 1);
              private_keyhole_body.params.alpha = t(.0, 1.0f, duration_const * k, duration_const, EaseOut);
              draw_safe(0, 1, t(0, 1, 0, duration_const, Linear));
          } else {
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              scale = t(0.5f, 1.0f, 0, duration_const * private_back_k, EaseOut);
              private_door.params.scale = xyzMake(scale, scale, 1);
              private_door.params.alpha = t(.0, 1.0f, 0, duration_const * private_back_k, EaseOut);
              draw_textured_shape(&private_door, main_matrix, NORMAL_ONE);
  
              glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
              private_stroke.params.rotation = private_scroll_offset;
              private_stroke.params.alpha = t(0, 1, 0, duration_const * 0.25f, Linear);
              private_stroke.params.position = xyzMake(0, 0, 0);
              scale = t(63, 63 * 2, 0, duration_const * private_back_k, EaseOut);
              change_rounded_rectangle_stroked(&private_stroke, CSizeMake(scale, scale), scale / 2.0f);
              draw_shape(&private_stroke, main_matrix);
  
              glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
              scale = t(00.5f, 1.0, 0, duration_const * private_back_k, EaseOut);
              private_keyhole_body.params.rotation = private_scroll_offset;
              private_keyhole_body.params.scale = xyzMake(scale, scale, 1);
              private_keyhole_body.params.alpha = t(.0, 1.0f, 0, duration_const * private_back_k, EaseOut);
  
              if (time < duration_const * .4) {
                  cloud_cover.params.position.y = t_reversed(118 / 2 + 50, 118 / 2, duration_const * 0.8f * private_back_k, duration_const * private_back_k, EaseOut);
                  draw_shape(&cloud_cover, main_matrix);
              }
  
              draw_safe(0, t(0, 1, duration_const * private_back_k * 0.0f, duration_const * private_back_k, Linear), t(0, 1, 0, duration_const, Linear));
          }
      } else if (current_page == 5) {
          float private_fade_k = 0.5f;
  
          rglNormalDraw();
  
          glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
          scale = 1;
          private_door.params.scale = xyzMake(scale, scale, 1);
          private_door.params.alpha = t(1, 0, 0, duration_const * private_fade_k * 0.5f, EaseOut);
          draw_textured_shape(&private_door, main_matrix, NORMAL_ONE);
  
          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
          private_stroke.params.rotation = private_scroll_offset;
          private_stroke.params.alpha = t(1, 0, 0, duration_const * private_fade_k * 0.5f, EaseOut);
          scale = t(244 / 2, r2 * 2, 0, duration_const, EaseOut);
          change_rounded_rectangle_stroked(&private_stroke, CSizeMake(scale, scale), scale / 2.0f);
          draw_shape(&private_stroke, main_matrix);
  
          glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
          scale = 1;
          private_keyhole_body.params.rotation = private_scroll_offset;
          private_keyhole_body.params.scale = xyzMake(scale, scale, 1);
          private_keyhole_body.params.alpha = t(1.0, 0.0, 0, duration_const * private_fade_k * 0.5f, EaseOut);
          privateLayer.rotation = private_scroll_offset;
          mat4x4_layer(private_matrix, privateLayer, t(1, 0.9f, 0, duration_const * private_fade_k, EaseOut), 0);
          cloud_cover.params.position.y = t(118 / 2 + 50, 118 / 2, 0, duration_const, EaseOut);
          draw_shape(&cloud_cover, main_matrix);
      }
  
      prev_page = current_page;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setScrollOffset(JNIEnv *env, jclass class, float a_offset) {
      scroll_offset = a_offset;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setPage(JNIEnv *env, jclass class, int32_t page) {
      if (current_page == page) {
          return;
      } else {
          prev_page = current_page;
          current_page = page;
          direct = current_page > prev_page ? 1 : 0;
          date0 = date;
          time = 0;
      }
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setDate(JNIEnv *env, jclass class, float a) {
      date = a;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setIcTextures(JNIEnv *env, jclass class, GLuint a_ic_bubble_dot, GLuint a_ic_bubble, GLuint a_ic_cam_lens, GLuint a_ic_cam, GLuint a_ic_pencil, GLuint a_ic_pin, GLuint a_ic_smile_eye, GLuint a_ic_smile, GLuint a_ic_videocam) {
      ic_bubble_dot_texture = a_ic_bubble_dot;
      ic_bubble_texture = a_ic_bubble;
      ic_cam_lens_texture = a_ic_cam_lens;
      ic_cam_texture = a_ic_cam;
      ic_pencil_texture = a_ic_pencil;
      ic_pin_texture = a_ic_pin;
      ic_smile_eye_texture = a_ic_smile_eye;
      ic_smile_texture = a_ic_smile;
      ic_videocam_texture = a_ic_videocam;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setTelegramTextures(JNIEnv *env, jclass class, GLuint a_telegram_sphere, GLuint a_telegram_plane) {
      telegram_sphere_texture = a_telegram_sphere;
      telegram_plane_texture = a_telegram_plane;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setFastTextures(JNIEnv *env, jclass class, GLuint a_fast_body, GLuint a_fast_spiral, GLuint a_fast_arrow, GLuint a_fast_arrow_shadow) {
      fast_spiral_texture = a_fast_spiral;
      fast_body_texture = a_fast_body;
      fast_arrow_shadow_texture = a_fast_arrow_shadow;
      fast_arrow_texture = a_fast_arrow;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setFreeTextures(JNIEnv *env, jclass class, GLuint a_knot_up, GLuint a_knot_down) {
      free_knot_up_texture = a_knot_up;
      free_knot_down_texture = a_knot_down;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setPowerfulTextures(JNIEnv *env, jclass class, GLuint a_powerful_mask, GLuint a_powerful_star, GLuint a_powerful_infinity, GLuint a_powerful_infinity_white) {
      powerful_mask_texture = a_powerful_mask;
      powerful_star_texture = a_powerful_star;
      powerful_infinity_texture = a_powerful_infinity;
      powerful_infinity_white_texture = a_powerful_infinity_white;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_setPrivateTextures(JNIEnv *env, jclass class, GLuint a_private_door, GLuint a_private_screw) {
      private_door_texture = a_private_door;
      private_screw_texture = a_private_screw;
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_onSurfaceCreated(JNIEnv *env, jclass class) {
  
      ms0 = 0;
      date = 1;
      date0 = 0;
      direct = 0;
      i = 0;
      current_page = 0;
      prev_page = 0;
      time = 0;
      time_local = 0;
      offset_y = 0;
      ribbonLength = 86.5f;
      starsFar = 500;
      scroll_offset = 0;
      calculated_speedometer_sin = 0;
      ms0_anim = 0;
      fps_anim = 0;
      count_anim_fps = 0;
      speedometer_scroll_offset = 0;
      free_scroll_offset = 0;
      private_scroll_offset = 0;
      anim_pencil_start_time = 0;
      anim_pencil_start_all_time = 0;
      anim_pencil_start_all_end_time = 0;
      anim_pencil_stage = 0;
      anim_bubble_dots_stage = 0;
      anim_bubble_dots_end_period = 0;
      anim_videocam_start_time = 0;
      anim_videocam_next_time = 0;
      anim_videocam_duration = 0;
      anim_videocam_angle = 0;
      anim_videocam_old_angle = 0;
      anim_cam_start_time = 0;
      anim_cam_next_time = 0;
      anim_cam_duration = 0;
      anim_cam_angle = 0;
      anim_cam_old_angle = 0;
      qShot = 0;
      anim_camshot_start_time = 0;
      anim_camshot_duration = 0;
      anim_smile_start_time1 = 0;
      anim_smile_start_time2 = 0;
      anim_smile_blink_start_time = 0;
      anim_smile_blink_one = 0;
      anim_smile_stage = 0;
      scale = 0;
      anim_pin_start_time = 0;
      anim_pin_duration = 0;
      anim_pencil_period = 0;
      cloud_scroll_offset = 0;
  
      setup_shaders();
  
      vec4 start_button_col = {44 / 255.0f, 165 / 255.0f, 224 / 255.0f, 1.0f};
      start_button = create_rounded_rectangle(CSizeMake(172, 44), 2, 3, start_button_col);
      start_button.params.anchor.y = -22;
  
      mask1 = create_rounded_rectangle(CSizeMake(60, 60), 0, 16, black_color);
  
      telegram_sphere = create_textured_rectangle(CSizeMake(150, 150), telegram_sphere_texture);
      telegram_plane = create_textured_rectangle(CSizeMake(82, 74), telegram_plane_texture);
      telegram_plane.params.anchor = xyzMake(6, -5, 0);
  
      fast_body = create_textured_rectangle(CSizeMake(148, 148), fast_body_texture);
  
      fast_arrow_shadow = create_textured_rectangle(CSizeMake(164 / 2, 44 / 2), fast_arrow_shadow_texture);
      fast_arrow_shadow.params.position.x = -1;
      fast_arrow_shadow.params.position.y = 2;
  
      fast_arrow = create_textured_rectangle(CSizeMake(164 / 2, 44 / 2), fast_arrow_texture);
      fast_arrow.params.anchor.x = fast_arrow_shadow.params.anchor.x = -19;
  
      int32_t ang = 180;
      spiral = create_segmented_square(r1, D2R(35 + 1), D2R(35 + 1 - 10 + ang), fast_spiral_texture);
  
      vec4 free_bg_color = {246 / 255.0f, 73 / 255.0f, 55 / 255.0f, 1};
      free_bg = create_rectangle(CSizeMake(160 * 2, 160 * 2), free_bg_color);
  
      free_knot1 = create_textured_rectangle(CSizeMake(138 / 3, 138 / 3), free_knot_up_texture);
      free_knot1.params.anchor.x = -23 + 10;
      free_knot1.params.anchor.y = 23 - 10;
  
      free_knot2 = create_textured_rectangle(CSizeMake(138 / 3, 138 / 3), free_knot_up_texture);
      free_knot2.params.anchor.x = -23 + 10;
      free_knot2.params.anchor.y = 23 - 10;
  
      free_knot3 = create_textured_rectangle(CSizeMake(150 / 3, 150 / 3), free_knot_down_texture);
      free_knot3.params.anchor.x = -100 / 4.0f + 20 / 2.0f;
      free_knot3.params.anchor.y = -100 / 4.0f + 20 / 2.0f;
  
      free_knot4 = create_textured_rectangle(CSizeMake(150 / 3, 150 / 3), free_knot_down_texture);
      free_knot4.params.anchor.x = -100 / 4.0f + 20 / 2.0f;
      free_knot4.params.anchor.y = -100 / 4.0f + 20 / 2.0f;
  
  
      ribbonLayer = default_layer_params();
  
      ribbon1 = create_ribbon(ribbonLength, white_color);
      ribbon1.params.layer_params = ribbonLayer;
  
      ribbon2 = create_ribbon(ribbonLength, white_color);
      ribbon2.params.rotation = 90;
      ribbon2.params.layer_params = ribbonLayer;
  
      ribbon3 = create_ribbon(ribbonLength, white_color);
      ribbon3.params.rotation = 180;
      ribbon3.params.layer_params = ribbonLayer;
  
      ribbon4 = create_ribbon(ribbonLength, white_color);
      ribbon4.params.rotation = 270;
      ribbon4.params.layer_params = ribbonLayer;
  
      ribbon1.params.position.y = ribbon2.params.position.y = ribbon3.params.position.y = ribbon4.params.position.y = -9;
  
  
      ic_bubble_dot = create_textured_rectangle(CSizeMake(18 / 3, 18 / 3), ic_bubble_dot_texture);
      ic_bubble = create_textured_rectangle(CSizeMake(102 / 3, 102 / 3), ic_bubble_texture);
      ic_cam_lens = create_textured_rectangle(CSizeMake(36 / 3, 36 / 3), ic_cam_lens_texture);
      ic_cam = create_textured_rectangle(CSizeMake(108 / 3, 96 / 3), ic_cam_texture);
      ic_pencil = create_textured_rectangle(CSizeMake(86 / 3, 86 / 3), ic_pencil_texture);
      ic_pin = create_textured_rectangle(CSizeMake(90 / 3, 120 / 3), ic_pin_texture);
      ic_smile_eye = create_textured_rectangle(CSizeMake(18 / 3, 18 / 3), ic_smile_eye_texture);
      ic_smile = create_textured_rectangle(CSizeMake(120 / 3, 120 / 3), ic_smile_texture);
      ic_videocam = create_textured_rectangle(CSizeMake(144 / 3, 84 / 3), ic_videocam_texture);
  
      ic_pin_layer = ic_cam_layer = ic_videocam_layer = ic_smile_layer = ic_bubble_layer = ic_pencil_layer = default_layer_params();
  
      ic_pin_layer.anchor = xyzMake(0, 50 / 2, 0);
      ic_pencil_layer.anchor = xyzMake(-30 / 2, 30 / 2, 0);
  
      infinity = create_infinity(11.7, .0, 32, white_color);
  
      vec4 powerful_bg_color = {47 / 255.f, 90 / 255.f, 131 / 255.f, 1};
      powerful_bg = create_rectangle(CSizeMake(200, 200), powerful_bg_color);
      powerful_mask = create_textured_rectangle(CSizeMake(200, 200), powerful_mask_texture);
  
      powerful_infinity = create_textured_rectangle(CSizeMake(366 / 3, 180 / 3), powerful_infinity_texture);
      powerful_infinity_white = create_textured_rectangle(CSizeMake(366 / 3, 180 / 3), powerful_infinity_white_texture);
  
      float star_radius = 5.25;
      star = create_textured_rectangle(CSizeMake(star_radius, star_radius), powerful_star_texture);
      star.params.const_params.is_star = 1;
      for (i = 0; i < starsCount; i++) {
          stars[i] = default_params();
          stars[i].position = star_create_position(-(i * 1500.0f) / starsCount);
      }
  
      privateLayer = default_layer_params();
  
      vec4 private_bg_color = {200 / 255.f, 207 / 255.f, 212 / 255.f, 1};
      private_bg = create_rectangle(CSizeMake(240, 240), private_bg_color);
  
      private_door = create_textured_rectangle(CSizeMake(408 / 3, 408 / 3), private_door_texture);
      private_keyhole_body = create_textured_rectangle(CSizeMake(216 / 3, 216 / 3), private_keyhole_body_texture);
      private_screw = create_textured_rectangle(CSizeMake(30 / 3, 30 / 3), private_screw_texture);
      private_stroke = create_rounded_rectangle_stroked(CSizeMake(244 / 2, 244 / 2), 21, 9, 16, white_color);
  
      int32_t cloud_polygons_count = 64;
      cloud_extra_mask1 = create_circle(1, cloud_polygons_count, black_color);
      cloud_extra_mask2 = create_circle(1, cloud_polygons_count, black_color);
      cloud_extra_mask3 = create_circle(1, cloud_polygons_count, black_color);
      cloud_extra_mask4 = create_circle(1, cloud_polygons_count, black_color);
  
      cloud_cover = create_rectangle(CSizeMake(240, 100), white_color);
      cloud_cover.params.anchor.y = -50;
  
      vec4 cloud_color = {42 / 255.0f, 180 / 255.0f, 247 / 255.0f, 1};
      cloud_bg = create_rectangle(CSizeMake(160 * 2, 160 * 2), cloud_color);
  }
  
  JNIEXPORT void Java_com_same_lib_intro_Intro_onSurfaceChanged(JNIEnv *env, jclass class, int32_t a_width_px, int32_t a_height_px, float a_scale_factor, int32_t a1) {
      glViewport(0, 0, a_width_px, a_height_px);
      width = (int32_t) (a_width_px / a_scale_factor);
      height = (int32_t) (a_height_px / a_scale_factor);
      scale_factor = a_scale_factor;
      mat4x4_plain(main_matrix, (int32_t) ((float) a_width_px / a_scale_factor), (int32_t) ((float) a_height_px / a_scale_factor));
      offset_y = a1 * main_matrix[1][1];
      set_y_offset_objects(offset_y);
      y_offset_absolute = a1;
      mat4x4_stars(stars_matrix, 45, 1, -1000, 0, (int32_t) ((float) a_width_px / a_scale_factor), (int32_t) ((float) a_height_px / a_scale_factor));
  }