gt: 		bytes[offset + 4] = (byte) (l & 0xff);
context: package net.osmand.util;
  
  
  import java.io.Closeable;
  import java.io.EOFException;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  import net.osmand.PlatformUtil;
  
  import org.apache.commons.logging.Log;
  
  
  /**
   * Basic algorithms that are not in jdk 
   */
  public class Algorithms {
  	private static final int BUFFER_SIZE = 1024;
  	private static final Log log = PlatformUtil.getLog(Algorithms.class);
  	
  	public static boolean isEmpty(String s){
  		return s == null || s.length() == 0;
  	}
  	
  	public static long parseLongSilently(String input, long def) {
  		if(input != null && input.length() > 0) {
  			try {
  				return Long.parseLong(input);
  			} catch (NumberFormatException e) {
  				return def;
  			}
  		}
  		return def;
  	}
  	
  	public static int findFirstNumberEndIndex(String value) {
  		int i = 0;
  		boolean valid = false;
  		if (value.length() > 0 && value.charAt(0) == '-') {
  			i++;
  		}
  		while (i < value.length() && (Character.isDigit(value.charAt(i)) || value.charAt(i) == '.')) {
  			i++;
  			valid = true;
  		}
  		if (valid) {
  			return i;
  		} else {
  			return -1;
  		}
  	}
  	
  	/**
  	 * Determine whether a file is a ZIP File.
  	 */
  	public static boolean isZipFile(File file) throws IOException {
  		if (file.isDirectory()) {
  			return false;
  		}
  		if (!file.canRead()) {
  			throw new IOException("Cannot read file " + file.getAbsolutePath());
  		}
  		if (file.length() < 4) {
  			return false;
  		}
  		FileInputStream in = new FileInputStream(file);
  		int test = readInt(in);
  		in.close();
  		return test == 0x504b0304;
  	}
  	
  	private static final int readInt(InputStream in) throws IOException {
          int ch1 = in.read();
          int ch2 = in.read();
          int ch3 = in.read();
          int ch4 = in.read();
          if ((ch1 | ch2 | ch3 | ch4) < 0)
              throw new EOFException();
          return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + ch4);
      }
  	
  	public static String capitalizeFirstLetterAndLowercase(String s) {
  		if (s != null && s.length() > 1) {
  			// not very efficient algorithm
  			return Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
  		} else {
  			return s;
  		}
  	}
  	
  	
  	public static boolean objectEquals(Object a, Object b){
  		if(a == null){
  			return b == null;
  		} else {
  			return a.equals(b);
  		}
  	}
  	
  	
  	/**
       	* Parse the color string, and return the corresponding color-int.
       	* If the string cannot be parsed, throws an IllegalArgumentException
       	* exception. Supported formats are:
       	* #RRGGBB
       	* #AARRGGBB
       	* 'red', 'blue', 'green', 'black', 'white', 'gray', 'cyan', 'magenta',
       	* 'yellow', 'lightgray', 'darkgray'
       	*/
      	public static int parseColor(String colorString) {
          	if (colorString.charAt(0) == '#') {
              	// Use a long to avoid rollovers on #ffXXXXXX
              	long color = Long.parseLong(colorString.substring(1), 16);
              	if (colorString.length() == 7) {
  	                // Set the alpha value
          	        color |= 0x00000000ff000000;
              	} else if (colorString.length() != 9) {
                  	throw new IllegalArgumentException("Unknown color " + colorString); //$NON-NLS-1$
              	}
              	return (int)color;
          	}
          	throw new IllegalArgumentException("Unknown color " + colorString); //$NON-NLS-1$
      	}
  	
  	public static int extractFirstIntegerNumber(String s) {
  		int i = 0;
  		for (int k = 0; k < s.length(); k++) {
  			if (Character.isDigit(s.charAt(k))) {
  				i = i * 10 + (s.charAt(k) - '0');
  			} else {
  				break;
  			}
  		}
  		return i;
  	}
  	
  	public static String extractIntegerSuffix(String s) {
  		int k = 0;
  		for (; k < s.length(); k++) {
  			if (!Character.isDigit(s.charAt(k))) {
  				return s.substring(k);
  			}
  		}
  		return "";
  	}
  	
  	
  	public static void streamCopy(InputStream in, OutputStream out) throws IOException{
  		byte[] b = new byte[BUFFER_SIZE];
  		int read;
  		while ((read = in.read(b)) != -1) {
  			out.write(b, 0, read);
  		}
  	}
  	
  	public static void oneByteStreamCopy(InputStream in, OutputStream out) throws IOException{
  		int read;
  		while ((read = in.read()) != -1) {
  			out.write(read);
  		}
  	}
  	
  	public static void closeStream(Closeable stream){
  		try {
  			if(stream != null){
  				stream.close();
  			}
  		} catch(IOException e){
  			log.warn("Closing stream warn", e); //$NON-NLS-1$
  		}
  	}
  	
  	public static void updateAllExistingImgTilesToOsmandFormat(File f){
  		if(f.isDirectory()){
  			for(File c : f.listFiles()){
  				updateAllExistingImgTilesToOsmandFormat(c);
  			}
  		} else if(f.getName().endsWith(".png") || f.getName().endsWith(".jpg")){ //$NON-NLS-1$ //$NON-NLS-2$
  			f.renameTo(new File(f.getAbsolutePath() + ".tile")); //$NON-NLS-1$
  		} else if(f.getName().endsWith(".andnav2")) { //$NON-NLS-1$
  			f.renameTo(new File(f.getAbsolutePath().substring(0, f.getAbsolutePath().length() - ".andnav2".length()) + ".tile")); //$NON-NLS-1$ //$NON-NLS-2$
  		}
  			
  	}
  	
  	public static boolean removeAllFiles(File f) {
  		if (f == null) {
  			return false;
  		}
  		if (f.isDirectory()) {
  			File[] fs = f.listFiles();
  			if(fs != null) {
  			  for (File c : fs) {
  			   removeAllFiles(c);
  			  }
  			}
  			return f.delete();
  		} else {
  			return f.delete();
  		}
  	}
  	
  	
  	public static long parseLongFromBytes(byte[] bytes, int offset) {
  		long o= 0xff & bytes[offset + 7];
  		o = o << 8 | (0xff & bytes[offset + 6]);
  		o = o << 8 | (0xff & bytes[offset + 5]);
  		o = o << 8 | (0xff & bytes[offset + 4]);
  		o = o << 8 | (0xff & bytes[offset + 3]);
  		o = o << 8 | (0xff & bytes[offset + 2]);
  		o = o << 8 | (0xff & bytes[offset + 1]);
  		o = o << 8 | (0xff & bytes[offset]);
  		return o;
  	}
  	
  	
  	
  	public static void putLongToBytes(byte[] bytes, int offset, long l){
  		bytes[offset] = (byte) (l & 0xff);
  		l >>= 8;
  		bytes[offset + 1] = (byte) (l & 0xff);
  		l >>= 8;
  		bytes[offset + 2] = (byte) (l & 0xff);
  		l >>= 8;
  		bytes[offset + 3] = (byte) (l & 0xff);
  		l >>= 8;
  