gt: 	for (int i = 0; i < lengthList[_id]; i++) {
context: package de.cb_map.osm.low_memory;
  
  import de.cb_map.osm.low_memory.Arrays.IByteArray;
  
  import java.io.UnsupportedEncodingException;
  import java.util.Arrays;
  
  /**
   * Represented the same like java.lang.LMString, bad stored only four bytes
   * for a integer ID.
   * <p/>
   * Created by Longri on 24.01.16.
   */
  public class LMString {
  
      static final int INITIAL_SIZE = 5;
      static byte[] STRING_MAP = new byte[INITIAL_SIZE];
      static int[] indexList = new int[INITIAL_SIZE];
      static short[] lengthList = new short[INITIAL_SIZE];
  
      static int lastIindex = 0;
      static int lastIndexListIndex = 0;
  
      public LMString(IByteArray array, int offset, int length) {
  	this(array.getBytes(offset, length));
      }
  
      /**
       * Returns the index, if LMString exist at store.
       * Returns -1 if the LMString not in the store.
       *
       * @param string
       * @return
       */
      static int containsValue(java.lang.String string) throws UnsupportedEncodingException {
  	return containsValue(string.getBytes(ParseConst.CHARSET_UTF8));
      }
  
      static int containsValue(byte[] bytes) {
  	return containsValue(bytes, 0, (short) bytes.length);
      }
  
      static int containsValue(byte[] bytes, int srcOffset, short srcLength) {
  	int index = 0;
  	for (int idx : indexList) {
  	    int length = lengthList[index];
  
  	    if (length == srcLength) {
  		boolean equals = true;
  		for (int i = 0; i < length; i++) {
  		    if (bytes[srcOffset + i] != STRING_MAP[idx + i]) {
  			equals = false;
  			break;
  		    }
  		}
  		if (equals)
  		    return index;
  	    }
  	    index++;
  	}
  	return -1;
      }
  
      static void chkRange(int length) {
  	if (STRING_MAP.length < lastIindex + length) {
  	    resize((STRING_MAP.length << 1) + length);
  	}
      }
  
      static void resize(int newSize) {
  	if (newSize < INITIAL_SIZE)
  	    newSize = INITIAL_SIZE;
  	if (STRING_MAP == null) {
  	    STRING_MAP = new byte[newSize];
  	} else {
  	    STRING_MAP = Arrays.copyOf(STRING_MAP, newSize);
  	}
      }
  
      public static void clearStore() {
  	lastIindex = 0;
  	lastIndexListIndex = 0;
  	STRING_MAP = new byte[INITIAL_SIZE];
  	indexList = new int[INITIAL_SIZE];
  	lengthList = new short[INITIAL_SIZE];
      }
  
      final int _id;
  
      public LMString(byte[] bytes, int offset, short length) {
  
  	int existId = containsValue(bytes, offset, length);
  
  	if (existId != -1) {
  	    _id = existId;
  	} else {
  	    chkRange(length + 2);
  
  	    //add to index list for search
  	    _id = addToIndexList(lastIindex, length);
  	    System.arraycopy(bytes, offset, STRING_MAP, lastIindex, length);
  	    lastIindex += length;
  	}
      }
  
      private static int addToIndexList(int idx, short length) {
  	if (indexList.length < lastIndexListIndex + 2) {
  	    // grow up indexList
  	    int newSize = indexList.length << 1;
  	    indexList = Arrays.copyOf(indexList, newSize);
  	    lengthList = Arrays.copyOf(lengthList, newSize);
  	}
  	indexList[lastIndexListIndex] = idx;
  	lengthList[lastIndexListIndex] = length;
  	return lastIndexListIndex++;
      }
  
      public LMString(java.lang.String string) throws UnsupportedEncodingException {
  	this(string.getBytes(ParseConst.CHARSET_UTF8));
      }
  
      public LMString(byte[] bytes) {
  	this(bytes, 0, (short) bytes.length);
  
      }
  
      LMString(int StringID) {
  	_id = StringID;
      }
  
      /**
       * Returns the length of this string.
       * The length is equal to the number of <a href="Character.html#unicode">Unicode
       * code units</a> in the string.
       *
       * @return the length of the sequence of characters represented by this
       * object.
       */
      public int length() {
  	return lengthList[_id];
      }
  
      /**
       * Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>.
       *
       * @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise
       * <tt>false</tt>
       * @since 1.6
       */
      public boolean isEmpty() {
  	return lengthList[_id] == 0;
      }
  
      /**
       * Compares this string to the specified object.  The result is {@code
       * true} if and only if the argument is not {@code null} and is a {@code
       * LMString} object that represents the same sequence of characters as this
       * object.
       *
       * @param anObject The object to compare this {@code LMString} against
       * @return {@code true} if the given object represents a {@code LMString}
       * equivalent to this string, {@code false} otherwise
       */
      public boolean equals(Object anObject) {
  	if (this == anObject) {
  	    return true;
  	}
  	if (anObject instanceof LMString) {
  	    if (_id == ((LMString) anObject)._id)
  		return true;
  	}
  	if (anObject instanceof String) {
  	    try {
  		LMString otherLMStringConst = new LMString((String) anObject);
  		return this._id == otherLMStringConst._id;
  	    } catch (UnsupportedEncodingException e) {
  		e.printStackTrace();
  	    }
  	}
  	if (anObject instanceof LMStringConst) {
  	    return Arrays.equals(this.getBytes(), ((LMStringConst) anObject).getBytes());
  	}
  
  	return false;
      }
  
      public java.lang.String toString() {
  	java.lang.String retString = "@?@?@";
  	try {
  	    retString = new java.lang.String(STRING_MAP, indexList[_id], lengthList[_id], ParseConst.CHARSET_UTF8);
  	} catch (UnsupportedEncodingException e) {
  	    e.printStackTrace();
  	}
  	return retString;
      }
  
      public byte[] getBytes() {
  
  	byte[] bytes = new byte[lengthList[_id]];
  
  	int idx = indexList[_id];
  
  	for (int i = 0; i < lengthList[_id]; i++) {
  	    bytes[i] = STRING_MAP[idx + i];
  	}
  
  	return bytes;
      }
  
      public boolean equalsIgnoreCase(LMString other) {
  	if (lengthList[_id] != lengthList[other._id])
  	    return false;
  	return Arrays.equals(lowerCase(), other.lowerCase());
      }
  
      public boolean equalsIgnoreCase(String other) throws UnsupportedEncodingException {
  	LMString otherString = new LMString(other);
  	return this.equalsIgnoreCase(otherString);
      }
  
      public boolean equalsIgnoreCase(LMStringConst other) {
  	return Arrays.equals(lowerCase(), other.lowerCase());
      }
  
      public byte[] lowerCase() {
  	// higer case range 65(A)- 90(Z)
  	byte[] b = new byte[lengthList[_id]];
  
  	int bufferOffset = indexList[_id];
  
  