text:
package playn.ios;

import cli.OpenTK.Graphics.ES20.GL;
import cli.System.Runtime.InteropServices.GCHandle;
import cli.System.Runtime.InteropServices.GCHandleType;
import static cli.OpenTK.Graphics.ES20.All.*;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

import playn.core.gl.GL20;

// Extremely incomplete!
public class IOSGL20 implements GL20 {

  @Override
  public String getPlatformGLExtensions() {
    // String extensions = GL.GetString(GL._EXTENSIONS);
    // return extensions;
    throw new UnsupportedOperationException();
  }

  @Override
  public int getSwapInterval() {
    // return 0;
    throw new UnsupportedOperationException();
  }

  @Override
  public void glActiveTexture(int texture) {
    // GL.ActiveTexture(wrap(texture));
    throw new UnsupportedOperationException();
  }

  @Override
  public void glAttachShader(int program, int shader) {
    // GL.AttachShader(program, shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBindAttribLocation(int program, int index, String name) {
    // GL.BindAttribLocation(program, index, name);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBindBuffer(int target, int buffer) {
    // GL.BindBuffer(target, buffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBindFramebuffer(int target, int framebuffer) {
    // GL.BindFramebuffer(target, framebuffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBindRenderbuffer(int target, int renderbuffer) {
    // GL.BindRenderbuffer(target, renderbuffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBindTexture(int target, int texture) {
    // GL.BindTexture(wrap(target), texture);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBlendColor(float red, float green, float blue, float alpha) {
    // GL.BlendColor(red, green, blue, alpha);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBlendEquation(int mode) {
    // GL.BlendEquation(wrap(mode));
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBlendEquationSeparate(int modeRGB, int modeAlpha) {
    // GL.BlendEquationSeparate(wrap(modeRGB), wrap(modeAlpha));
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBlendFunc(int sfactor, int dfactor) {
    // GL.BlendFunc(wrap(sfactor), wrap(dfactor));
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
    // GL.BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glBufferData(int target, int size, Buffer data, int usage) {
    // GL.BufferData(target, size, data, usage);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glBufferSubData(int target, int offset, int size, Buffer data) {
    // GL.BufferSubData(target, offset, size, data);
    throw new UnsupportedOperationException();

  }

  @Override
  public int glCheckFramebufferStatus(int target) {
    // return GL.CheckFramebufferStatus(target);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glClear(int mask) {
    // GL.Clear(mask);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glClearColor(float red, float green, float blue, float alpha) {
    // GL.ClearColor(red, green, blue, alpha);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glClearDepth(double depth) {
    // GL.ClearDepthf((float) depth);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glClearDepthf(float depth) {
    // GL.ClearDepthf(depth);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glClearStencil(int s) {
    // GL.ClearStencil(s);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
    // GL.ColorMask(red, green, blue, alpha);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompileShader(int shader) {
    // GL.CompileShader(shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexImage2D(int target, int level, int internalformat, int width,
         int height, int border, int imageSize, Buffer data) {
    // GL.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize,
    //     data);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexImage2D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, Buffer arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, int arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width,
         int height, int format, int imageSize, Buffer data) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexSubImage2D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, int arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexSubImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, int arg8, int arg9, Buffer arg10) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCompressedTexSubImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, int arg8, int arg9, int arg10) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCopyTexImage2D(int target, int level, int internalformat, int x, int y, int width,
         int height, int border) {
    // GL.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y,
         int width, int height) {
    // GL.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCopyTexSubImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
         int arg6, int arg7, int arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public int glCreateProgram() {
    // return GL.CreateProgram();
    throw new UnsupportedOperationException();
  }

  @Override
  public int glCreateShader(int type) {
    // return GL.CreateShader(type);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glCullFace(int mode) {
    // GL.CullFace(mode);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteBuffers(int n, int[] buffers, int offset) {
    // GL.DeleteBuffers(n, buffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteBuffers(int n, IntBuffer buffers) {
    // GL.DeleteBuffers(n, buffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteFramebuffers(int n, int[] framebuffers, int offset) {
    // GL.DeleteFramebuffers(n, framebuffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteFramebuffers(int n, IntBuffer framebuffers) {
    // GL.DeleteFramebuffers(n, framebuffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteProgram(int program) {
    // GL.DeleteProgram(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteRenderbuffers(int n, int[] renderbuffers, int offset) {
    // GL.DeleteRenderbuffers(n, renderbuffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteRenderbuffers(int n, IntBuffer renderbuffers) {
    // GL.DeleteRenderbuffers(n, renderbuffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteShader(int shader) {
    // GL.DeleteShader(shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteTextures(int n, int[] textures, int offset) {
    // GL.DeleteTextures(n, textures, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDeleteTextures(int n, IntBuffer textures) {
    // GL.DeleteTextures(n, textures);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDepthFunc(int func) {
    // GL.DepthFunc(func);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDepthMask(boolean flag) {
    // GL.DepthMask(flag);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDepthRange(double zNear, double zFar) {
    // GL.DepthRangef((float) zNear, (float) zFar);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glDepthRangef(float zNear, float zFar) {
    // GL.DepthRangef(zNear, zFar);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDetachShader(int program, int shader) {
    // GL.DetachShader(program, shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDisable(int cap) {
    // GL.Disable(cap);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDisableVertexAttribArray(int index) {
    // GL.DisableVertexAttribArray(index);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDrawArrays(int mode, int first, int count) {
    // GL.DrawArrays(mode, first, count);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDrawElements(int mode, int count, int type, Buffer indices) {
    // GL.DrawElements(mode, count, type, indices);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glDrawElements(int mode, int count, int type, int offset) {
    // GL.DrawElements(mode, count, type, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glEnable(int cap) {
    // GL.Enable(cap);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glEnableVertexAttribArray(int index) {
    // GL.EnableVertexAttribArray(index);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFinish() {
    // GL.Finish();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFlush() {
    // GL.Flush();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget,
         int renderbuffer) {
    // GL.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFramebufferTexture2D(int target, int attachment, int textarget, int texture,
         int level) {
    // GL.FramebufferTexture2D(target, attachment, textarget, texture, level);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFramebufferTexture3D(int target, int attachment, int textarget, int texture,
         int level, int zoffset) {
    // GL.FramebufferTexture2D(target, attachment, textarget, texture, level);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glFrontFace(int mode) {
    // GL.FrontFace(mode);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenBuffers(int n, int[] buffers, int offset) {
    // GL.GenBuffers(n, buffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenBuffers(int n, IntBuffer buffers) {
    // GL.GenBuffers(n, buffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenerateMipmap(int target) {
    // GL.GenerateMipmap(target);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenFramebuffers(int n, int[] framebuffers, int offset) {
    // GL.GenFramebuffers(n, framebuffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenFramebuffers(int n, IntBuffer framebuffers) {
    // GL.GenFramebuffers(n, framebuffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenRenderbuffers(int n, int[] renderbuffers, int offset) {
    // GL.GenRenderbuffers(n, renderbuffers, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenRenderbuffers(int n, IntBuffer renderbuffers) {
    // GL.GenRenderbuffers(n, renderbuffers);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenTextures(int n, int[] textures, int offset) {
    // GL.GenTextures(n, textures, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGenTextures(int n, IntBuffer textures) {
    // GL.GenTextures(n, textures);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetActiveAttrib(int program, int index, int bufsize, int[] length,
         int lengthOffset, int[] size, int sizeOffset, int[] type, int typeOffset, byte[] name,
         int nameOffset) {
    // GL.GetActiveAttrib(program, index, bufsize, length, lengthOffset, size, sizeOffset, type,
    //     typeOffset, name, nameOffset);
    throw new UnsupportedOperationException();

  }

  @Override
  public void glGetActiveAttrib(int program, int index, int bufsize, IntBuffer length,
         IntBuffer size, IntBuffer type, ByteBuffer name) {
    // int namePos = name.position();
    // GL.GetActiveAttrib(program, index, bufsize, length, size, type, name.get());
    // name.position(namePos);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetActiveUniform(int program, int index, int bufsize, int[] length,
         int lengthOffset, int[] size, int sizeOffset, int[] type, int typeOffset, byte[] name,
         int nameOffset) {
    // GL.GetActiveUniform(program, index, bufsize, length, lengthOffset, size, sizeOffset,
    //     type, typeOffset, name, nameOffset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetActiveUniform(int program, int index, int bufsize, IntBuffer length,
         IntBuffer size, IntBuffer type, ByteBuffer name) {
    // int namePos = name.position();
    // GL.GetActiveUniform(program, index, bufsize, length, size, type, name.get());
    // name.position(namePos);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetAttachedShaders(int program, int maxcount, int[] count, int countOffset,
         int[] shaders, int shadersOffset) {
    // GL.GetAttachedShaders(program, maxcount, count, countOffset, shaders, shadersOffset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetAttachedShaders(int program, int maxcount, IntBuffer count, IntBuffer shaders) {
    // GL.GetAttachedShaders(program, maxcount, count, shaders);
    throw new UnsupportedOperationException();
  }

  @Override
  public int glGetAttribLocation(int program, String name) {
    // return GL.GetAttribLocation(program, name);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glGetBoolean(int pname) {
    // byte[] out = new byte[1];
    // glGetBooleanv(pname, out, 0);
    // return out[0] != GL_FALSE;
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetBooleanv(int pname, byte[] params, int offset) {
    // ByteBuffer buffer = ByteBuffer.wrap(params, offset, params.length - offset);
    // GL.GetBooleanv(pname, buffer.asIntBuffer());
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetBooleanv(int pname, ByteBuffer params) {
    // GL.GetBooleanv(pname, params.asIntBuffer());
    throw new UnsupportedOperationException();
  }

  @Override
  public int glGetBoundBuffer(int arg0) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetBufferParameteriv(int target, int pname, int[] params, int offset) {
    // GL.GetBufferParameteriv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetBufferParameteriv(int target, int pname, IntBuffer params) {
    // GL.GetBufferParameteriv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public int glGetError() {
    // return GL.GetError();
    throw new UnsupportedOperationException();
  }

  @Override
  public float glGetFloat(int pname) {
    // float[] out = new float[1];
    // GL.GetFloatv(pname, out, 0);
    // return out[0];
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetFloatv(int pname, float[] params, int offset) {
    // GL.GetFloatv(pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetFloatv(int pname, FloatBuffer params) {
    // GL.GetFloatv(pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname,
         int[] params, int offset) {
    // GL.GetFramebufferAttachmentParameteriv(target, attachment, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname,
         IntBuffer params) {
    // GL.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public int glGetInteger(int pname) {
    // int[] out = new int[1];
    // GL.GetIntegerv(pname, out, 0);
    // return out[0];
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetIntegerv(int pname, int[] params, int offset) {
    // GL.GetIntegerv(pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetIntegerv(int pname, IntBuffer params) {
    // GL.GetIntegerv(pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetProgramBinary(int arg0, int arg1, int[] arg2, int arg3, int[] arg4, int arg5,
         Buffer arg6) {
    throw new RuntimeException("glGetProgramBinary not supported.");
  }

  @Override
  public void glGetProgramBinary(int arg0, int arg1, IntBuffer arg2, IntBuffer arg3, Buffer arg4) {
    throw new RuntimeException("glGetProgramBinary not supported.");
  }

  @Override
  public void glGetProgramInfoLog(int program, int bufsize, int[] length, int lengthOffset,
         byte[] infolog, int infologOffset) {
    // String log = GL.GetProgramInfoLog(program);
    // byte[] byteArray = log.getBytes();
    // for (int i = 0; i < bufsize && i < byteArray.length; i++) {
    //   infolog[i + infologOffset] = byteArray[i];
    // }
    // length[lengthOffset] = log.length();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetProgramInfoLog(int program, int bufsize, IntBuffer length, ByteBuffer infolog) {
    // glGetProgramInfoLog(program, bufsize, length.array(), infolog.position(), infolog.array(),
    //     infolog.position());
    throw new UnsupportedOperationException();
  }

  @Override
  public String glGetProgramInfoLog(int program) {
    // return GL.GetProgramInfoLog(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetProgramiv(int program, int pname, int[] params, int offset) {
    // GL.GetProgramiv(program, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetProgramiv(int program, int pname, IntBuffer params) {
    // GL.GetProgramiv(program, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetRenderbufferParameteriv(int target, int pname, int[] params, int offset) {
    // GL.GetRenderbufferParameteriv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetRenderbufferParameteriv(int target, int pname, IntBuffer params) {
    // GL.GetRenderbufferParameteriv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderInfoLog(int shader, int bufsize, int[] length, int lengthOffset,
         byte[] infolog, int infologOffset) {
    // String log = GL.GetShaderInfoLog(shader);
    // byte[] byteArray = log.getBytes();
    // for (int i = 0; i < bufsize && i < byteArray.length; i++) {
    //   infolog[i + infologOffset] = byteArray[i];
    // }
    // length[lengthOffset] = log.length();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderInfoLog(int shader, int bufsize, IntBuffer length, ByteBuffer infolog) {
    // glGetShaderInfoLog(shader, bufsize, length.array(), length.position(), infolog.array(),
    //     infolog.position());
  }

  @Override
  public String glGetShaderInfoLog(int shader) {
    // return GL.GetShaderInfoLog(shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderiv(int shader, int pname, int[] params, int offset) {
    // GL.GetShaderiv(shader, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderiv(int shader, int pname, IntBuffer params) {
    // GL.GetShaderiv(shader, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderPrecisionFormat(int shadertype, int precisiontype, int[] range,
         int rangeOffset, int[] precision, int precisionOffset) {
    // GL.GetShaderPrecisionFormat(shadertype, precisiontype, range, rangeOffset, precision,
    //     precisionOffset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderPrecisionFormat(int shadertype, int precisiontype, IntBuffer range,
         IntBuffer precision) {
    // GL.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderSource(int shader, int bufsize, int[] length, int lengthOffset,
         byte[] source, int sourceOffset) {
    // GL.GetShaderSource(shader, bufsize, length, lengthOffset, source, sourceOffset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetShaderSource(int shader, int bufsize, IntBuffer length, ByteBuffer source) {
    // GL.GetShaderSource(shader, bufsize, length.array(), 0, source.array(), 0);
    throw new UnsupportedOperationException();
  }

  @Override
  public String glGetString(int name) {
    // return GL.GetString(name);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetTexParameterfv(int target, int pname, float[] params, int offset) {
    // GL.GetTexParameterfv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetTexParameterfv(int target, int pname, FloatBuffer params) {
    // GL.GetTexParameterfv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetTexParameteriv(int target, int pname, int[] params, int offset) {
    // GL.GetTexParameteriv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetTexParameteriv(int target, int pname, IntBuffer params) {
    // GL.GetTexParameteriv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetUniformfv(int program, int location, float[] params, int offset) {
    // GL.GetUniformfv(program, location, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetUniformfv(int program, int location, FloatBuffer params) {
    // GL.GetUniformfv(program, location, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetUniformiv(int program, int location, int[] params, int offset) {
    // GL.GetUniformiv(program, location, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetUniformiv(int program, int location, IntBuffer params) {
    // GL.GetUniformiv(program, location, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public int glGetUniformLocation(int program, String name) {
    // return GL.GetUniformLocation(program, name);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetVertexAttribfv(int index, int pname, float[] params, int offset) {
    // GL.GetVertexAttribfv(index, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetVertexAttribfv(int index, int pname, FloatBuffer params) {
    // GL.GetVertexAttribfv(index, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetVertexAttribiv(int index, int pname, int[] params, int offset) {
    // GL.GetVertexAttribiv(index, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glGetVertexAttribiv(int index, int pname, IntBuffer params) {
    // GL.GetVertexAttribiv(index, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glHint(int target, int mode) {
    // GL.Hint(target, mode);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsBuffer(int buffer) {
    // return GL.IsBuffer(buffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsEnabled(int cap) {
    // return GL.IsEnabled(cap);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsFramebuffer(int framebuffer) {
    // return GL.IsFramebuffer(framebuffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsProgram(int program) {
    // return GL.IsProgram(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsRenderbuffer(int renderbuffer) {
    // return GL.IsRenderbuffer(renderbuffer);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsShader(int shader) {
    // return GL.IsShader(shader);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsTexture(int texture) {
    // return GL.IsTexture(texture);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsVBOArrayEnabled() {
    // return isExtensionAvailable("vertex_buffer_object");
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glIsVBOElementEnabled() {
    // return glIsVBOArrayEnabled();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glLineWidth(float width) {
    // GL.LineWidth(width);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glLinkProgram(int program) {
    // GL.LinkProgram(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public ByteBuffer glMapBuffer(int arg0, int arg1) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glPixelStorei(int pname, int param) {
    // GL.PixelStorei(pname, param);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glPolygonOffset(float factor, float units) {
    // GL.PolygonOffset(factor, units);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glProgramBinary(int arg0, int arg1, Buffer arg2, int arg3) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glReadPixels(int x, int y, int width, int height, int format, int type, Buffer pixels) {
    // GL.ReadPixels(x, y, width, height, format, type, pixels);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glReadPixels(int x, int y, int width, int height, int format, int type,
         int pixelsBufferOffset) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glReleaseShaderCompiler() {
    // GL.ReleaseShaderCompiler();
    throw new UnsupportedOperationException();
  }

  @Override
  public void glRenderbufferStorage(int target, int internalformat, int width, int height) {
    // GL.RenderbufferStorage(target, internalformat, width, height);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glSampleCoverage(float value, boolean invert) {
    // GL.SampleCoverage(value, invert);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glScissor(int x, int y, int width, int height) {
    // GL.Scissor(x, y, width, height);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glShaderBinary(int n, int[] shaders, int offset, int binaryformat, Buffer binary,
         int length) {
    // GL.ShaderBinary(n, shaders, offset, binaryformat, binary, length);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glShaderBinary(int n, IntBuffer shaders, int binaryformat, Buffer binary, int length) {
    // GL.ShaderBinary(n, shaders, binaryformat, binary, length);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glShaderSource(int shader, int count, String[] strings, int[] length, int lengthOffset) {
    // int totalLength = 0;
    // for (int i = lengthOffset; i < length.length; i++) {
    //   totalLength += length[i];
    // }
    // StringBuilder builder = new StringBuilder(totalLength);

    // for (int j = 0; j < count; j++) {
    //   builder.append(strings[j], 0, length[j]);
    // }

    // GL.ShaderSource(shader, builder.toString());
    throw new UnsupportedOperationException();
  }

  @Override
  public void glShaderSource(int shader, int count, String[] strings, IntBuffer length) {
    // glShaderSource(shader, count, strings, length.array(), 0);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glShaderSource(int shader, String string) {
    // GL.ShaderSource(shader, string);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilFunc(int func, int ref, int mask) {
    // GL.StencilFunc(wrap(func), ref, mask);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilFuncSeparate(int face, int func, int ref, int mask) {
    // GL.StencilFuncSeparate(face, func, ref, mask);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilMask(int mask) {
    // GL.StencilMask(mask);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilMaskSeparate(int face, int mask) {
    // GL.StencilMaskSeparate(face, mask);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilOp(int fail, int zfail, int zpass) {
    // GL.StencilOp(fail, zfail, zpass);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glStencilOpSeparate(int face, int fail, int zfail, int zpass) {
    // GL.StencilOpSeparate(face, fail, zfail, zpass);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexImage2D(int target, int level, int internalformat, int width, int height,
         int border, int format, int type, Buffer pixels) {
    if (pixels != null) {
      GCHandle handle = createHandle(pixels);
      GL.TexImage2D(wrap(target), level, internalformat, width, height, border,
                    wrap(format), wrap(type), handle.AddrOfPinnedObject());
      handle.Free();
    } else {
      GL.TexImage2D(wrap(target), level, internalformat, width, height, border,
                    wrap(format), wrap(type), null);
    }
  }

  @Override
  public void glTexImage2D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8, Buffer arg9) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8, int arg9) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameterf(int target, int pname, float param) {
    // GL.TexParameterf(target, pname, param);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameterfv(int target, int pname, float[] params, int offset) {
    // GL.TexParameterfv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameterfv(int target, int pname, FloatBuffer params) {
    // GL.TexParameterfv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameteri(int target, int pname, int param) {
    // GL.TexParameteri(target, pname, param);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameteriv(int target, int pname, int[] params, int offset) {
    // GL.TexParameteriv(target, pname, params, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexParameteriv(int target, int pname, IntBuffer params) {
    // GL.TexParameteriv(target, pname, params);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexSubImage2D(int target, int level, int xoffset, int yoffset, int width,
         int height, int format, int type, Buffer pixels) {
    // GL.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexSubImage2D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexSubImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8, int arg9, Buffer arg10) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glTexSubImage3D(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6,
         int arg7, int arg8, int arg9, int arg10) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1f(int location, float x) {
    // GL.Uniform1f(location, x);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1fv(int location, int count, float[] v, int offset) {
    // GL.Uniform1fv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1fv(int location, int count, FloatBuffer v) {
    // GL.Uniform1fv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1i(int location, int x) {
    // GL.Uniform1i(location, x);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1iv(int location, int count, int[] v, int offset) {
    // GL.Uniform1iv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform1iv(int location, int count, IntBuffer v) {
    // GL.Uniform1iv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2f(int location, float x, float y) {
    // GL.Uniform2f(location, x, y);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2fv(int location, int count, float[] v, int offset) {
    // GL.Uniform2fv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2fv(int location, int count, FloatBuffer v) {
    // GL.Uniform2fv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2i(int location, int x, int y) {
    // GL.Uniform2i(location, x, y);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2iv(int location, int count, int[] v, int offset) {
    // GL.Uniform2iv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform2iv(int location, int count, IntBuffer v) {
    // GL.Uniform2iv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3f(int location, float x, float y, float z) {
    // GL.Uniform3f(location, x, y, z);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3fv(int location, int count, float[] v, int offset) {
    // GL.Uniform3fv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3fv(int location, int count, FloatBuffer v) {
    // GL.Uniform3fv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3i(int location, int x, int y, int z) {
    // GL.Uniform3i(location, x, y, z);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3iv(int location, int count, int[] v, int offset) {
    // GL.Uniform3iv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform3iv(int location, int count, IntBuffer v) {
    // GL.Uniform3iv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4f(int location, float x, float y, float z, float w) {
    // GL.Uniform4f(location, x, y, z, w);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4fv(int location, int count, float[] v, int offset) {
    // GL.Uniform4fv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4fv(int location, int count, FloatBuffer v) {
    // GL.Uniform4fv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4i(int location, int x, int y, int z, int w) {
    // GL.Uniform4i(location, x, y, z, w);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4iv(int location, int count, int[] v, int offset) {
    // GL.Uniform4iv(location, count, v, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniform4iv(int location, int count, IntBuffer v) {
    // GL.Uniform4iv(location, count, v);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix2fv(int location, int count, boolean transpose, float[] value,
      int offset) {
    // GL.UniformMatrix2fv(location, count, transpose, value, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix2fv(int location, int count, boolean transpose, FloatBuffer value) {
    // GL.UniformMatrix2fv(location, count, transpose, value);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix3fv(int location, int count, boolean transpose, float[] value,
      int offset) {
    // GL.UniformMatrix3fv(location, count, transpose, value, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix3fv(int location, int count, boolean transpose, FloatBuffer value) {
    // GL.UniformMatrix3fv(location, count, transpose, value);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix4fv(int location, int count, boolean transpose, float[] value,
      int offset) {
    // GL.UniformMatrix4fv(location, count, transpose, value, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUniformMatrix4fv(int location, int count, boolean transpose, FloatBuffer value) {
    // GL.UniformMatrix4fv(location, count, transpose, value);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean glUnmapBuffer(int arg0) {
    throw new UnsupportedOperationException();
  }

  @Override
  public void glUseProgram(int program) {
    // GL.UseProgram(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glValidateProgram(int program) {
    // GL.ValidateProgram(program);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib1f(int indx, float x) {
    // GL.VertexAttrib1f(indx, x);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib1fv(int indx, float[] values, int offset) {
    // GL.VertexAttrib1fv(indx, values, offset);

    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib1fv(int indx, FloatBuffer values) {
    // GL.VertexAttrib1fv(indx, values);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib2f(int indx, float x, float y) {
    // GL.VertexAttrib2f(indx, x, y);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib2fv(int indx, float[] values, int offset) {
    // GL.VertexAttrib2fv(indx, values, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib2fv(int indx, FloatBuffer values) {
    // GL.VertexAttrib2fv(indx, values);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib3f(int indx, float x, float y, float z) {
    // GL.VertexAttrib3f(indx, x, y, z);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib3fv(int indx, float[] values, int offset) {
    // GL.VertexAttrib3fv(indx, values, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib3fv(int indx, FloatBuffer values) {
    // GL.VertexAttrib3fv(indx, values);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib4f(int indx, float x, float y, float z, float w) {
    // GL.VertexAttrib4f(indx, x, y, z, w);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib4fv(int indx, float[] values, int offset) {
    // GL.VertexAttrib4fv(indx, values, offset);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttrib4fv(int indx, FloatBuffer values) {
    // GL.VertexAttrib4fv(indx, values);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
       Buffer ptr) {
    // GL.VertexAttribPointer(indx, size, type, normalized, stride, ptr);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride,
       int ptr) {
    // GL.VertexAttribPointer(indx, size, type, normalized, stride, ptr);
    throw new UnsupportedOperationException();
  }

  @Override
  public void glViewport(int x, int y, int width, int height) {
    // GL.Viewport(x, y, width, height);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean hasGLSL() {
    // return true;
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean isExtensionAvailable(String extension) {
    // String extensions = GL.GetString(GL._EXTENSIONS);
    // return extensions.contains(extension);
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean isFunctionAvailable(String function) {
    // Method[] functions = this.getClass().getMethods();
    // for (int i = 0; i < functions.length; i++) {
    //   if (function == functions[i].getName())
    //     return true;
    // }
    // return false;
    throw new UnsupportedOperationException();
  }

  /** Allocates a pinned GCHandle pointing at a buffer's data. Remember to free it! */
  private static GCHandle createHandle (Buffer buffer)
  {
    Object array;
    if (buffer instanceof ByteBuffer)
      array = ((ByteBuffer)buffer).array();
    else if (buffer instanceof ShortBuffer)
      array = ((ShortBuffer)buffer).array();
    else if (buffer instanceof IntBuffer)
      array = ((IntBuffer)buffer).array();
    else if (buffer instanceof FloatBuffer)
      array = ((FloatBuffer)buffer).array();
    else if (buffer instanceof DoubleBuffer)
      array = ((DoubleBuffer)buffer).array();
    else
      throw new IllegalArgumentException();
    return GCHandle.Alloc(array, GCHandleType.wrap(GCHandleType.Pinned));
  }
}


text:
Orange inaugurates 4G network in six cities
In line with previously announced plans, Spanish cellco Orange Espana has launched commercial 4G services in the cities of Madrid, Barcelona, Valencia, Seville, Malaga and Murcia. In confirming that its LTE-based services were now live, Orange Espana noted that it has invested around EUR70 million (USD89.9 million) for the modernisation of its network in Madrid alone. As a result of such investment, the cellco has said that at launch its 4G infrastructure covers around 80% of the population of Madrid within the perimeter of the M40 motorway, or around three million people.
Orange is the second Spanish wireless operator to introduce commercial 4G services, with Vodafone Spain having been the first to do so at the end of May 2013. As reported by CommsUpdate, Vodafone switched on its LTE network in a total of seven cities on 29 May 2013, those being: Barcelona, Bilbao, Madrid, Malaga, Palma de Mallorca, Seville and Valencia. At launch the mobile network operator claimed that its 4G services were available to approximately 55% of the population in the aforementioned locations, having rolled out the technology over the 1800MHz and 2600MHz bands.
Spain, Orange Espana (incl. Jazztel), Mobile, LTE

redpajama_set_name: RedPajamaCommonCrawl


2017 marks the 10-year anniversary of the boutique opening. To celebrate, Blushing Boutique will be hosting a party with an open studio. Master of Ceremonies, actress and singer, Karen Holness will host the main event, a retro fashion show followed by a showing of the Fall 17 Collection and a sneak peak of the Holiday collection. The "Blushing Throughout the Years" fashion show will showcase signature Shelley Klassen designs from 1999-2017. There will be many draw prizes from local businesses and contests at the event, including a contest for the "Best Blushing Outfit" with a grand prize of a $250 gift certificate. There will also be a live DJ, and appetizers and refreshments.
The event will also showcase local design talent. Blushing Boutique carries accessories and jewellery by over 10 different local Vancouver designers. The designers featured at the event include Bronsino Leather Designs by Denise Wilson, JFG Designs Jewellery by Jules F, and Earth Essence Jewellery by Tamara Ryan.
Owner and designer Shelley Klassen launched her line Blushing Designs in 1999 and opened her flagship boutique in 2007 on Richards St. in downtown Vancouver. Prior to opening the boutique, Klassen wholesaled her line to over 65 boutiques across Canada, as well as boutiques, in LA, Australia and Dubai.
Dress Code: Cocktail / Black Tie Optional – Wear Your Favourite Blushing Design!


text:
Effects and Pedals → Chorus → Animals Car Crush Chorus & Vibrato
Animals Car Crush Chorus & Vibrato
Out of stock - Click to Order
SKU: ae00-16683^CARCRUSH
There was a psychedelic sound born in the chaotic world of the late 60s. That sound has been supported by a unique modulation effects pedal from Japan.
It's a waving, quivering sort of sound. The heavy tones revolve around while jolting quickly. The sounds coming from this mysterious box that most people at the time didn't even know the name of are further deifying the sounds of left-handed guitarists that are even now regarded as gods.
Uni-Vibe. That was what this device was called. Artists throughout the world are still trying to get their hands on the original model.
The Animals Pedal Car Crush Chorus / Vibe is a Chorus / Vibrato pedal for making that vintage modulation sound simple.
If you combine it with a classical distortion effect you can recreate the enthusiasm of the late 60s. Unlike the expensive, hard-to-find original model, it's compact, simple, easy to use, and can be easily carried around so you can enjoy that "vibe sound."
It's not limited to classic tones. For example, if you combine it with an expansive dreamy reverb type effect or something like that, you can create a new sound.
It's a compact pedal with just 3 control knobs and toggle switches. Experience the sound I'm talking about.
DEPTH: Adjusts the depth of the vibration.
RATE: Adjusts the speed of the vibration.
COLOR: Makes fine adjustments to the frequency response to control the sound.
CHORUS-VIBE: Chooses a chorus and vibe effect.
The Car Crush Chorus / Vibe uses a true bypass switch, and is powered by 9V battery or a standard DC9V center minus power adapter.
Power consumption: 5.5mA
Input Impedance: 500k
Output Impedance: 10k
Model: CARCRUSH
Manufacturer: Animals Pedals


text:
Royalty Owners
NGL Energy Partners
About NGL
Segments Overview
Crude Oil Logistics
NGL Liquids
Refined Products / Renewables
Refined / Renewables
NGL Energy Water Solutions
The Water Solutions segment provides services for the treatment and disposal of wastewater generated from crude oil and natural gas production and for the disposal of solids such as tank bottoms and drilling fluids and performs truck and frac tank washouts. In addition, the Water Solutions segment sells the recovered hydrocarbons that result from performing these services.
Asset Overview
~115 water treatment and disposal facilities, including ~204 disposal wells across the Permian, Eagle Ford, DJ, Granite Wash, Pinedale Anticline, and Eaglebine
Combined total of ~5.9 million bpd of permitted disposal capacity
8 facilities that can dispose of solids such as tank bottoms and drilling fluids
Numerous water pipelines which directly connect from oil and gas producing wells to NGL's saltwater disposal facilities
Currently >60% of wastewater on pipelines, continuing to increase across the footprint
NGL Water Facility
Water Solutions Management
Doug White
Executive Vice President –
NGL Energy Partners LP
6120 South Yale Avenue, Suite 805
info@nglep.com
investorinfo@nglep.com
NGL Home
Refined/Renewables
INVESTOR LINKS
©2019 NGL Energy Partners LP
Mr. Boland is a Managing Director and Co-head of Midstream at EIG Global Energy Partners where he leads the firm's investment activities in the midstream sector on a global basis. Prior to joining EIG in 2011, Mr. Boland worked at Credit Suisse in New York where he was a member of the Global Energy and Leveraged Finance groups. Mr. Boland also currently serves as a director of Limetree Bay Ventures, LLC, Elba Liquefaction Company, L.L.C., Midship Holdings, LLC, and is a board observer at Cheniere Corpus Christi Holdings, LLC. Mr. Boland holds a B.S.B.A. in Finance and Accounting from Georgetown University.
Audra Hamilton
Senior Vice President of Administration and Legal Counsel
Ms. Hamilton joined NGL in February of 2015 as the Director of Training and Compliance. Since that time, Ms. Hamilton has held positions of increasing responsibility within the Human Resources, Benefits, and Insurance departments, while acting as counsel on employment law matters. Ms. Hamilton has represented and counseled companies for more than 20 years as a licensed attorney in the federal and state courts of Oklahoma and Arkansas. Prior to joining NGL, Ms. Hamilton was Of Counsel at Wilkin/McMurray PLLC; a partner at Doerner, Saunders, Daniel & Anderson, LP; and an Adjunct Professor of Employment Law at OSU-Tulsa. Ms. Hamilton has been an author and contributing author on several publications and a speaker at national conferences on employment law. Ms. Hamilton is a graduate of Hendrix College and the University of Arkansas School of Law.
Joshua Patterson
Senior Vice President – Water Solutions
Joshua Patterson joined NGL's wastewater treatment team in 2011 after managing the Town of Granby Colorado's and Town of Winter Park's wastewater treatment plants. Mr. Patterson earned the highest level of wastewater treatment, collection systems, and drinking water certifications in the state of Colorado. He has also worked for the Department of Interior and US Forestry Service. Since 2014, Mr. Patterson has been responsible for NGL's SWD and Recycling operations in North Dakota, Colorado, and Texas. He now serves as Sr. Vice President of Operations for the Water Solutions segment.
Jim Winter currently serves as the Senior Vice President of Water Solutions for NGL. Previously, Jim Winter joined High Sierra Energy, LP, in January of 2007, as Vice President of High Sierra Crude Oil & Marketing. He has over 30 years of experience in the energy industry. He began his career as an independent petroleum landman in 1979 with Joseph S. Rose & Company. In 1986, Mr. Winter co-founded High Plains Energy Company, an oil and gas land services firm that served a variety of E&P companies throughout the Rockies and northeastern U.S. In 1992, Mr. Winter joined Petro Source Partners, Ltd., where he managed the company's Permian Basin crude oil purchasing and transportation program. Petro Source was acquired in 2000 by SemGroup, where Mr. Winter was primarily involved in refined products marketing and the acquisition of refined products assets for SemFuel through 2006. Currently, Mr. Winter is Senior Vice President of High Sierra Water Holdings, where he oversees the operations of High Sierra's various water businesses. Mr. Winter received a B.S. degree from the University of Colorado in 1976 and an M.B.A. degree from the University of Colorado in 1978.
Executive Vice President – Water Solutions
Douglas W. White joined High Sierra Energy in 2007 as Vice President of NGL Power Marketing and currently serves as Executive Vice President of NGL Water Solutions where he oversees Water Solutions business segment. Mr. White received his B.S. from Regis University 2001 and began his 20 year career in energy with Aquila Power Corporation where he served as a marketing and trading representative in electricity and natural gas markets. In 2009, Mr. White joined High Sierra Energy Water Holdings as Manager, Produced Water Services where he helped grow the water segment through several acquisitions. Prior to his current position Mr. White served as Sr. Vice President of Operations in the Water Solutions segment.
NGL's website uses cookies. By proceeding, you consent to our cookie usage.Ok


They are small lights, but all with the authentic oil lamps.
As a result, these lights are quite pretty to use at home as mood lighting, or as decoration.
Also note the beautiful glass what in the lamps.
Very interesting article. Two extraordinary pieces. Very well packed. Thank you.
Das grüne Glas war gebrochen. Es war schlecht verpackt, sehr schade.
You can pick up this lot from the seller: Zoetermeer (), Netherlands.


A few weeks ago, over on our Facebook page, we told you that Daval's kitchen and bedroom designer, Dean Weavill, had been shortlisted for the New Designer Award at the Designer Kitchen and Bathroom Awards. Well we're delighted to announce that Dean actually scooped the award at the ceremony last night!
Dean won the award after submitting a case study using Daval's Oakley in-frame kitchen. The case study showcased a renovation project which removed a wall between the kitchen and dining room to create an open plan kitchen living space. The doors and walkways were also moved so a natural flow between the kitchen and hallway were formed, and patio doors were introduced to bring in lots of natural light as well as capture the views.
3Style Kitchens is the official Wakefield supplier for Daval kitchens (and now bedrooms!) with the majority of kitchens we supply manufactured by them here in Yorkshire. MD Dean Clements picked up our own award this year, winning the Best Home and Garden Retailer award at the Wakefield Retail Awards so by choosing us you get a kitchen or bedroom from 2 award winning companies (in fact, 2 award winning Deans!).
1 Response to "Daval Wins New Designer of the Year Award"


Fixing electric gate systems is our specialty, sure, but it's not our only specialty. Our professionals are well versed and experienced in the art that is garage door repair. From replacing broken springs and cables to troubleshooting and solving electric or mechanical opener problems, there's no situation our experts can't handle.
Why Did My Garage Door Spring Break?
There could be several reasons for this, but the most common is simple – old age. The older these units get, the more they wear out, and the more you use your door, the quicker that happens. Because the springs are the ones that counterbalance the weight of the door panels, they're under a lot of tension on a regular basis, and therefore their structural integrity will slowly degrade over time. These units work using a lot of tension, so you must never attempt to repair or replace a broken spring by yourself, as you could get seriously hurt.
A whole host of things could be the reason for this type of malfunction. From blocked or bent tracks to circuitry issues with your opener's logic board. Even the mechanical parts of your motor unit can create a problem, seeing as if one of them breaks or detaches, the opener won't be able to move the door. Leave it to our experts to run a diagnostics check to locate the source of the problem, and to then apply the appropriate solution. Your door will be back to its old self in no time.
Unfortunately, your garage door can experience a whole lot more problems, ranging all the way from worn rollers to broken panels. Whatever the issue, though, you can always count on Gate Repair Thousand Oaks to be there to provide an effective and affordable solution. Give us a call today and let us know what you need our technicians to do for you.


This page describes tools for working with the GFF format for genome feature annotation.
(to a new co-ordinate system) and dereferencing (access to the described sequence).
sophisticated algorithms like clustering and joining-together by dynamic programming.
Programs to perform all of these tasks are described below, with links to local copies.
is EXBLX, as used by MSPCrunch (Sonnhammer & Durbin: An expert system for processing sequence homology data. Proc Int Conf Intell Syst Mol Biol 1994;2:363-8.).
The tools are now rather outdated, and probably unnecessary for anyone who knows how to use a relational database, and can therefore use something like Chado. Nonetheless, they still find occasional use in our lab. YMMV.
by Tim Hubbard's GFF.pm module, but are more efficient (or at least they were at one point).
This is a significant consideration for chromosome-sized GFF files!
gffsubtract.pl - cuts out everything in one GFF file that overlaps with features in a second. Useful e.g. to find all unannotated regions in a genome.
cluster2gff.pl - converts a list of whitespace-separated NSE clusters (in the format "name/start-end") into a GFF data set.
gffhitcount - a C++ program that counts the number of times each base in a set of sequences is spanned by a GFF record and returns the results in GFF format.
EXBLX dynamic programming: bigdp - a C++ program that assembles EXBLX segments using an affine gap penalty by doing linear-space divide-and-conquer dynamic programming, written by Ian Holmes. The program does not examine the sequences to which the EXBLX data refer, but finds optimal connections between the segments given their co-ordinates. GFF pair format can be converted to EXBLX using gff2exblx.pl.
(SCORE, PERCENT-ID, START#1, END#1, NAME#1, START#2, END#2, NAME#2).
and a ninth field, compactly describing the co-ordinates of the input segments, is added.
The algorithm used by the program is documented more fully in Ian Holmes' PhD thesis.
GFF, a general-purpose genome annotation format, was conceived during a 1997 meeting on computational genefinding at the Isaac Newton Institute, Cambridge, UK.
in a common input format for multi-component genefinders, such as Reese et al.: Genie--gene finding in Drosophila melanogaster. Genome Res. 2000;10:529-38. or Howe et al.: GAZE: a generic framework for the integration of gene-prediction data by dynamic programming. Genome Res. 2002;12:1418-27. (downloadable from Sanger), that stitch together the results of specialized "sensor" or "predictor" programs in a Dynamic Programming (or particularly a Hidden Markov Model) framework.
At least the first three of these are useful enough, and the GFF syntax for null fields compact enough (1 byte), that GFF also caught on as a format for quick-and-dirty Perl-fuelled data mining at the Unix command line. Scorned by those who worship databases and ontologies, GFF gained a rep as a lo-tech genome-hackers' format, favored by sequence-mungers too busy for SQL.
Several other tools for these sorts of purposes exist (aside from, um, using a proper SQL database). For example, Tim Hubbard's perl modules. However the gfftools have a small underground following because they were built explicitly to be user-driven, interactive and fast, with time-consuming steps (like sorting, indexing or I/O) directly under the analyst's control.
These scripts are flawed, and by no means the most elegant or algorithmically thoughtful thing I ever wrote, but some people still use them. For these reasons, I've finally got around to putting them up on a public CVS server.
This page was moved from the Sanger GFF page by Ian Holmes on 21 March 2005.


Our aim at the Mare Nostrum Resort is for you to get to know Tenerife in the easiest and most comfortable way possible. This is why we place our Info Centre information point at your disposal in the Hotel Mediterranean Palace and it is open from 9am to 7pm.
- Information and promotion of sales points in the Mare Nostrum Resort and events in the resort: SPA, shows at the Pirámide de Arona, restaurants, bars, gala dinners, VIP cocktails, Resort shows, Summer Night Festival, Christmas Eve and New Year's Eve galas, etc.
- Processing and printing boarding cards.
- Hire of bicycles, wheelchairs, crutches and pushchairs.
- Processing and sending of lost and found objects.
- Arranging for a Babysitter.
- Processing booking special requests (flowers, cava, chocolates, etc.). Everything you request when booking will be ready for you on arrival at the Mare Nostrum Resort.
Come to the Pirámide de Arona and see the performances of Carmen Mota, an artist and internationally renowned choreographer who has dedicated her whole life to Spanish dance.
The coastline of Playa de las Américas and Los Cristianos in Tenerife has a number of fantastic beaches with golden sand. You'll find the Playa El Camisón beach, one of the best in Tenerife, right in front of the Mare Nostrum Resort. The Info Centre will provide you with information on the other beaches along the Tenerife coastline.
Tenerife is a fantastic island and we hope that during your stay you won't miss the opportunity of trying some of the water sports we can offer you. Make the most of Tenerife's famous and sublime beaches!
Tenerife is a world of fun, full of activities and natural corners which will fill your holiday with unforgettable moments. Vast golden beaches and remote coves with black sand ideal for practising water sports. Impressive, gigantic precipices and cliffs or impossibly-shaped volcanic lunar landscapes. Visit us at the Info Centre and we'll make you the best, tailor-made leisure proposals.
Where you come to Tenerife with your family, your partner or with friends, you shouldn't miss out on the great variety of theme parks we can recommend: water parks, extreme action, with animals, adventure... And they're all very close to the Mare Nostrum Resort!
If you're looking for a golf holiday in Tenerife, we'll make the best recommendations for you at the Mare Nostrum Resort and take care of everything: we'll provide you with the equipment you may need and book the course for you.
Transfer in a top range vehicle and a visit to the shopping centre of the island's capital, where you will find a wide selection of the top brands. Further information at the Info Centre on arrival at the resort.


text:
Mostly cloudy skies. A few flurries are possible. High 28F. Winds light and variable..
urgent web only
5 important stories you need to know from yesterday: olice release sketch of man allegedly impersonating officer; motorists warned to be on guard
Here's a look at the top 5 trending stories on nwi.com yesterday.
UPDATE: Police release sketch of man allegedly impersonating officer; motorists warned to be on guard
Bob Kasarda and Anna Ortiz Times Staff Writers
Drivers were warned Wednesday that a man posing as a police officer has been reportedly pulling over multiple women in Crown Point and Portage.
Indiana State Police and Portage police are investigating reports from multiple witnesses who have matching descriptions of the man and vehicle.
A 40-year-old Portage woman was on her way home from work at 2:30 p.m. July 17 when she was pulled over on Evergreen Avenue near the intersection of Clydia Street, Portage Police Chief Troy Williams said.
The dark blue car, which was possibly a Ford Crown Victoria, had flashing red and blue lights on the dashboard but no siren, Williams said in a written statement Wednesday.
The man who approached her vehicle following the stop was described as white, approximately 5-feet-5-inches tall, younger than 40 with short dark brown or black hair and a pencil-thin mustache, police said. The man wore a dark blue shirt, badge, radio and handcuffs, but no weapon was seen, Williams stated.
The suspect posing as a police officer told the woman he noticed her car parked at the bar where she works and had her blow into what he said was a portable alcohol breath test, police said.
After telling the woman she passed the test, he said he was letting her go with a warning.
The woman said she decided to report the incident to police after talking it over with her husband, police said.
"We are notifying the public to make them aware of the incident, to check if there were similar incidents and to remind people that if you feel there is something suspicious with a traffic stop to call 911 and/or ask for a patrol supervisor to come to the scene," Williams said.
Indiana State Police reported similar incidents involving two women happening within a nine-day period.
At 9:50 p.m. July 8, a woman said she was stopped on I-65 going southbound near the 109th Street exit in Crown Point by a dark Ford Crown Victoria with red and blue lights inside the windshield, according to an Indiana State police news release.
The woman described the driver as a white, older man with short gray hair and a mustache wearing khaki pants and a plain tan polo shirt. She said the man had no gun belt or weapons in view and he didn't use a flashlight when approaching her vehicle. She said the man didn't identify himself and was aggressive as he yelled at her for allegedly speeding.
He took her driver's license and registration back to his car where he sat for about five minutes before returning them. The man then told her that in a few weeks she would get a ticket in the mail. He said if she didn't take care of it, a warrant would be issued for her arrest.
The man's demeanor changed when he approached her car a second time, noticing that woman wasn't alone in her vehicle, she told police.
Another witness called state police saying a man also pulled her over at 109th Street while she was on her way home from work, ISP said.
The witness gave the same description of the man and told police the Crown Victoria had flashing white lights around the license plate in the rear in addition to the red and blue lights in the front windshield. Indiana state police searched the area after receiving the report and did not find the suspected impostor.
On Monday, Indiana State Police contacted the Portage Police Department and showed officers a sketch developed from ISP's investigations into the reports.
The Portage victim said the man she saw looks similar to the ISP sketch.
Anyone with any information on the suspect is asked to contact ISP Detective Brian McCall at 219-690-0083.
Recent arrests booked into Porter County Jail
Masked man in cuffs after bank employees thwart robberies, St. John police say
Lauren Cross lauren.cross@nwi.com, 219-933-3206
ST. JOHN — Police say a masked man reportedly attempted to rob two banks along U.S. 231 late Wednesday morning, but was thwarted by quick-thinking employees.
St. John Police Cmdr. Steven Flores said the suspect, allegedly wearing a mask, was first seen just before 10 a.m. at First Savings Bank of Hegewisch at U.S. 231 and Parrish Avenue.
A bank employee noticed him circling the bank in a black Jeep, so they decided to go on lockdown to prevent him from entering, he said.
Flores said bank employees made the smart choice of calling the bank down the street, First Merchants Bank at U.S. 231 and 41, to warn them of a possible suspect attempting to rob banks in the area.
"I think she saw him driving around the bank, locked the door, but then he left there, came here," Flores said. "While he was here, that bank called this one and said, 'Hey, we had a guy driving around our bank with a mask covering his face.' "
As the First Savings Bank teller was on the phone with First Merchants Bank, the suspect pulled into the First Merchants Bank parking lot, Flores said.
"She saw him and locked their doors right away," he said.
Flores said the suspect allegedly tugged on the doors at First Merchants Bank a few times "with his face covered."
The 911 call came in about 10:02 a.m., according to Cedar Lake Police Deputy Chief Carl Brittingham. St. John and Cedar Lake police responded.
The suspect was gone by the time police arrived, fleeing westbound on U.S. 231, north on Calumet Avenue and then over to Sheffield Avenue, police said.
Flores said the Dyer police chief and another officer saw the suspect's vehicle — a black Jeep with no plates — and initiated a traffic stop.
The suspect is now in custody at the St. John Police Department for processing.
"The banks did a phenomenal job," Flores said.
Check back at nwi.com for updates as this story develops.
Hard Rock Casino Gary to be built in two phases: casino to open by 2021; hotel, parking garage to follow
Dan Carden dan.carden@nwi.com, 219-933-3357
GARY — Hard Rock Casino Gary will have an attached hotel and parking garage, in addition to the Region's second-largest casino, a sports book, numerous bars and restaurants, including a Hard Rock Cafe, and a music performance venue known as Hard Rock Live.
Spectacle Entertainment officials told the Gary Plan Commission Tuesday that the gaming company hopes to open the land-based replacement for its Majestic Star casinos on Dec. 31, 2020, and then construct the hotel and parking facility within two to three years.
"We originally envisioned to do that all in one fell swoop, but then along came Illinois and that sort of set us back on our heels a little bit. But we're committed to this project and committed to doing it in two phases," said John Keeler, Spectacle vice president and general counsel.
In fact, Keeler said absent the increased competition likely coming as a result of the new Illinois law authorizing a Chicago mega-casino, along with a second new casino in south suburban Cook County, Spectacle's relocated Gary casino might not have been a Hard Rock Casino.
"That partnership was dictated by what happened in Illinois," Keeler said. "We felt if we were going to be able to compete in Gary and put out a first-class product — really attract people to our facility — we needed to partner with the gold standard, with the Rolls Royce if you will, in the casino gaming industry. And that's why we've partnered with Hard Rock, who will manage and brand this casino."
Rich Zeigler, Spectacle vice president of development, said Hard Rock designers still are crafting the exterior and interior look of the casino, and even where the different pieces will sit on the roughly 27-acre parcel immediately south of the Borman Expressway at the Burr Street exit.
"Illinois changed things for us a bit, and we're still working through the design process of exactly how big it is and the amenities," Zeigler said.
In general, he said, the casino will be approximately 200,000 square feet with "all of the amenities that you would see in a state-of-the-art and top-of-the-line casino," along with the hotel and parking garage.
"Those facilities will not be an afterthought," Zeigler emphasized. "They are part of the original design all the way through."
He said Hard Rock designers are working to ensure everything at the property is "best-of-the-best," based on Hard Rock's "tremendous experience with casinos — not only in the design but the construction of them."
There currently are 12 Hard Rock Casinos, most with hotels, operating or under construction in the United States, Canada and the Dominican Republic. Hard Rock also is bidding to operate the new casino authorized for Rockford, Illinois, near that state's border with Wisconsin.
Zeigler promised the Hard Rock Casino Gary will bring a unique look to the gaming experience in Northwest Indiana, even before patrons enter the facility.
"What the aesthetics of the property look like are very, very important to us," he said. "As you get off (Interstate) 80/94 onto Burr Street, the transformation of what this streetscape is going to look like will be dramatic."
The Gary Plan Commission unanimously authorized Spectacle's request for a planned unit development, giving Spectacle the first of several city and state regulatory board approvals required before construction can begin, which Keeler said could possibly still be this year.
Sarah Kobetis, Gary director of planning and zoning, said she believes the Hard Rock Casino development will be a great benefit for the community.
"It's going to be a very beautiful site, and I think it's going to be an impetus for a lot of economic development," Kobetis said.
Slideshow: Hard Rock Casinos elsewhere
UPDATE: Man arrested by SWAT team returned to victim's home after ordeal 2 days earlier
Olivia Heersink and Sarah Reese Times Staff Writers
DYER — A Cedar Lake man beat his girlfriend, robbed her and threatened to pull out her teeth with pliers before she escaped from him Thursday as he drove her truck in Harvey, Illinois, court records allege.
Carmine Sansone, 42, was arrested by a SWAT team Saturday night after he returned to the woman's Dyer home with a gun, according to police and court records.
The woman told Dyer police Friday that Sansone had been angry with her the past week, waved a gun at her and threatened to kill her.
On Thursday, she became so upset after arguing with him she called off work, records say.
When she entered her bedroom, Sansone pushed her down, choked her, grabbed her by the hair and pounded her face on a floor, records allege.
Sansone was smoking a white rock-like substance, which the woman suspected was drugs, records state. He told the woman she owed him $600 because she made him miss work and forced her into her truck, according to court records.
The woman told police she withdrew $600 from an ATM in Munster before Sansone drove to Illinois. At one point, he slammed her face against the passenger window, because he thought she was laughing at him, records allege.
He threatened to rip her teeth out with pliers and told her the man they were going to see in Illinois would have sex with her, records say.
Sansone allegedly ripped her clothing as she attempted to escape. She was able to break away from him and sought help inside a restaurant in Harvey, according to court records. She reported her truck stolen in Harvey.
Dyer police were dispatched to the woman's home Saturday for a report of a suspicious vehicle. Police located the vehicle, which was occupied by Brian George, Dyer Police Chief Dave Hein said.
George told police he drove Sansone to Dyer and Sansone had gone inside the home with a black revolver. Sansone allegedly told George he would "go down shooting" before going back to prison, according to court records.
Dyer police requested assistance from the Northwest Regional SWAT team, which took Sansone into custody, Hein said.
Police found a .38-caliber revolver in the same room where Sansone was located, records say. The gun had been reported stolen out of Chicago, police said.
Sansone was taken to the Lake County Jail, where he was being held Tuesday without bail.
Sansone was charged Monday with felony unlawful possession of a firearm by a serious violent felon, robbery, two counts of criminal confinement, strangulation, domestic battery resulting in moderate bodily injury, pointing a firearm, auto theft and a misdemeanor count of domestic battery.
Online court records did not yet list an attorney for Sansone.
UPDATE: Hobart woman identified in Lansing fatal shooting, coroners say
Olivia Heersink and Anna Ortiz Times Staff Writers
LANSING — A Hobart woman was gunned down in a busy Lansing parking lot, and another man was injured in the shooting, police and coroner's reports revealed Wednesday.
Lisa Marie York, 41, of Hobart, was fatally shot in the head, the Lake County coroner reported. She was pronounced dead at 6:45 p.m. Tuesday at Franciscan Health Hammond after the shooting incident near the intersection of 173rd Street and Torrence Avenue in Lansing.
Officers received a call for shots fired at 6:07 p.m., according to Lansing police. When they arrived, they discovered two victims in the parking lot at 2500 Bernice Road.
The second victim, a man, sustained multiple gunshot wounds to the body. He was taken to Advocate Christ Medical Center in Oak Lawn, where he remained in stable condition Wednesday afternoon, police said. The identity of the male victim was not released Wednesday.
The Lansing Police Department is working with the South Suburban Major Crimes Task Force on the investigation.
Anyone with information is asked to call the Lansing Police Department's Criminal Investigations Division at 708-895-7150.
Gunshots ring out
On Tuesday night, a black truck riddled with bullet holes sat in front of an automotive shop as police investigated the area.
Crime scene tape stretched from Just Tires, at 2500 173rd St., to the plaza parking lot across the roadway, which is home to a vacant building and an LA Fitness.
Shortly after 6 p.m., Zelda McDonald, of Lansing, had just parked and was about to head into LA Fitness when she heard what she described as 10 to 20 gunshots ring out.
"I stepped my foot out, and at first I thought it was a firecracker when the first shot happened," McDonald said. "The only thing I could think of was to fall back in my car."
McDonald said she heard several more shots fired before hearing a vehicle speed away.
"I went into shock," McDonald said. "I couldn't believe what was happening. You see this kind of thing on TV but not in real life."
McDonald waited and then ran as fast as she could into the LA Fitness building for safety.
Kevin Harmon, of Chicago, said he dropped off his vehicle at Just Tires about 2:30 p.m., went to see a movie with his family and then came back only to find the crime scene investigation in full swing.
Harmon was told he would need to wait for police to process the area before he could remove his vehicle. He said the plaza is normally a quiet, safe place — the reason he does business there.
"That's why I bring my car here to get services. It's out in the middle of nowhere," Harmon said.
Familiar territory
This wasn't the first time Lansing police have investigated a shooting in the 17300 block of Torrence Avenue.
On July 22, 2018 — nearly a year ago to the day of the recent shooting — 20-year-old Jessica Loverdi-Finister suffered a gunshot wound during a fight just outside the nearby LA Fitness, which McDonald said she entered for safety Tuesday.
In the 2018 case, a friend took Loverdi-Finister, of Sauk Village, to the now-shuttered Franciscan Health hospital in Chicago Heights, where she later died. The Cook County medical examiner ruled the death a homicide.
In September, police arrested Amari Ross, 20, of Chicago, and charged him with first-degree murder in Loverdi-Finister's death.
Coupon Book
Berey Bros
The safety shoe experts at Berey Bros. can help your business set up a safety footwear program. Call us today to learn more 1-888-949-BOOT or Click Here


A Namibian novelty: in one area of the Namibian dessert, more or less due West of Uis, people found new Actinolites, very sharp and with a slight green tint, making the specimens more agreeable than others that are blacker. We got this specimen, which is a floater and complete on all its sides, for its luster and perfection.
A novelty at Sainte Marie-aux-Mines 2018. Bundle-like aggregates of acicular Actinolite crystals with a clear pistachio green color, with black intergrowths of crystalline Ferro-actinolite. Very original. The sample has been analyzed and we'll send a copy of the analysis to the buyer.
A novelty at Sainte Marie-aux-Mines 2018. Bundle-like aggregates of acicular Actinolite crystals, one of them clearly dominant, with a clear pistachio green color, with black intergrowths of crystalline Ferro-actinolite. Very original. The sample has been analyzed and we'll send a copy of the analysis to the buyer.
A novelty at Sainte Marie-aux-Mines 2018. Bundle-like aggregates of acicular Actinolite crystals with a clear pistachio green color, with black intergrowths of crystalline Ferro-actinolite and white Prehnite crystals. Very original. The sample has been analyzed and we'll send a copy of the analysis to the buyer.
A novelty at Sainte Marie-aux-Mines 2018. Bundle-like aggregates of fibrous and acicular Actinolite crystals with a clear pistachio green color, with darker, almost black, intergrowths of crystalline Ferro-actinolite and partially coated by white Prehnite. The sample has been analyzed and we will send a copy of the analysis to the buyer.


The vendors and agencies we include in our list below are the top Magento experts working in Berlin. They strive and grow every day to bring good products and services to merchants which use Magento as an e-Commerce platform for their online stores all around the world. Magento experts work to design, develop, support and perfect Magento-based sites. Millions of issues are being solved everyday thanks to these enthusiasts.
All the vendors in Berlin have been working with many companies and organizations including from small/medium-sized firms to big businesses. Products are developed based on merchant's needs and requirements with the best services regardless of your company size.
Products and services offered by agencies in Berlin below can be varied in pricing, depending on the what services, versions, editions and your requirements are. Normally, prices are reasonable and flexible for you to choose.
Address: Industriestrasse 4, Stuttgart, Baden-Württemberg 70565, Germany.
Address: Frankfurter Allee 73c, Berlin, Berlin 10247, Germany.
Address: Hainburger Strasse 20/6, Wien, Wien 1030, Austria.


In a quiet environment , this house / villa (relaxation and well-being) of 34 m² (about 366 ft²), built in 2000 contains 2 rooms including 1 bedroom, 1 bathroom and 1 toilet. It is equipped with a living room of 23 m² (about 247 ft²), with a fitted kitchenette, with a swimming pool, with a terrace and with a parking lot. Heating : individual electric.