hbase/util/JenkinsHash.java

/**
 * Copyright 2007 The Apache Software Foundation
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.hadoop.hbase.util;

import java.io.FileInputStream;
import java.io.IOException;

/**
 * Produces 32-bit hash for hash table lookup.
 * 
 * <pre>lookup3.c, by Bob Jenkins, May 2006, Public Domain.
 *
 * You can use this free for any purpose.  It's in the public domain.
 * It has no warranty.
 * </pre>
 * 
 * @see <a href="http://burtleburtle.net/bob/c/lookup3.c">lookup3.c</a>
 * @see <a href="http://www.ddj.com/184410284">Hash Functions (and how this
 * function compares to others such as CRC, MD?, etc</a>
 * @see <a href="http://burtleburtle.net/bob/hash/doobs.html">Has update on the
 * Dr. Dobbs Article</a>
 */
public class JenkinsHash {
  private static long INT_MASK  = 0x00000000ffffffffL;
  private static long BYTE_MASK = 0x00000000000000ffL;

  private static long rot(long val, int pos) {
    return ((Integer.rotateLeft(
        (int)(val & INT_MASK), pos)) & INT_MASK);
  }

  /**
   * Alternate form for hashing an entire byte array
   * 
   * @param bytes
   * @return hash value
   */
  public static int hash(byte[] bytes) {
    return hash(bytes, bytes.length, -1);
  }
  
  /**
   * Alternate form for hashing an entire byte array
   * 
   * @param bytes 
   * @param initval
   * @return hash value
   */
  public static int hash(byte[] bytes, int initval) {
    return hash(bytes, bytes.length, initval);
  }
  
  /**
   * taken from  hashlittle() -- hash a variable-length key into a 32-bit value
   * 
   * @param key the key (the unaligned variable-length array of bytes)
   * @param nbytes number of bytes to include in hash
   * @param initval can be any integer value
   * @return a 32-bit value.  Every bit of the key affects every bit of the
   * return value.  Two keys differing by one or two bits will have totally
   * different hash values.
   * 
   * <p>The best hash table sizes are powers of 2.  There is no need to do mod
   * a prime (mod is sooo slow!).  If you need less than 32 bits, use a bitmask.
   * For example, if you need only 10 bits, do
   * <code>h = (h & hashmask(10));</code>
   * In which case, the hash table should have hashsize(10) elements.
   * 
   * <p>If you are hashing n strings byte[][] k, do it like this:
   * for (int i = 0, h = 0; i < n; ++i) h = hash( k[i], h);
   * 
   * <p>By Bob Jenkins, 2006.  bob_jenkins@burtleburtle.net.  You may use this
   * code any way you wish, private, educational, or commercial.  It's free.
   * 
   * <p>Use for hash table lookup, or anything where one collision in 2^^32 is
   * acceptable.  Do NOT use for cryptographic purposes.
  */
  @SuppressWarnings("fallthrough")
  public static int hash(byte[] key, int nbytes, int initval) {
    int length = nbytes;
    long a, b, c;       // We use longs because we don't have unsigned ints
    a = b = c = (0x00000000deadbeefL + length + initval) & INT_MASK;
    int offset = 0;
    for (; length > 12; offset += 12, length -= 12) {
      a = (a + (key[offset + 0]    & BYTE_MASK)) & INT_MASK;
      a = (a + (((key[offset + 1]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
      a = (a + (((key[offset + 2]  & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
      a = (a + (((key[offset + 3]  & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
      b = (b + (key[offset + 4]    & BYTE_MASK)) & INT_MASK;
      b = (b + (((key[offset + 5]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
      b = (b + (((key[offset + 6]  & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
      b = (b + (((key[offset + 7]  & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
      c = (c + (key[offset + 8]    & BYTE_MASK)) & INT_MASK;
      c = (c + (((key[offset + 9]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
      c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
      c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
      
      /*
       * mix -- mix 3 32-bit values reversibly.
       * This is reversible, so any information in (a,b,c) before mix() is
       * still in (a,b,c) after mix().
       * 
       * If four pairs of (a,b,c) inputs are run through mix(), or through
       * mix() in reverse, there are at least 32 bits of the output that
       * are sometimes the same for one pair and different for another pair.
       * 
       * This was tested for:
       * - pairs that differed by one bit, by two bits, in any combination
       *   of top bits of (a,b,c), or in any combination of bottom bits of
       *   (a,b,c).
       * - "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
       *   the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
       *    is commonly produced by subtraction) look like a single 1-bit
       *    difference.
       * - the base values were pseudorandom, all zero but one bit set, or
       *   all zero plus a counter that starts at zero.
       * 
       * Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
       * satisfy this are
       *     4  6  8 16 19  4
       *     9 15  3 18 27 15
       *    14  9  3  7 17  3
       * Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for 
       * "differ" defined as + with a one-bit base and a two-bit delta.  I
       * used http://burtleburtle.net/bob/hash/avalanche.html to choose
       * the operations, constants, and arrangements of the variables.
       * 
       * This does not achieve avalanche.  There are input bits of (a,b,c)
       * that fail to affect some output bits of (a,b,c), especially of a.
       * The most thoroughly mixed value is c, but it doesn't really even
       * achieve avalanche in c.
       * 
       * This allows some parallelism.  Read-after-writes are good at doubling
       * the number of bits affected, so the goal of mixing pulls in the
       * opposite direction as the goal of parallelism.  I did what I could.
       * Rotates seem to cost as much as shifts on every machine I could lay
       * my hands on, and rotates are much kinder to the top and bottom bits,
       * so I used rotates.
       *
       * #define mix(a,b,c) \
       * { \
       *   a -= c;  a ^= rot(c, 4);  c += b; \
       *   b -= a;  b ^= rot(a, 6);  a += c; \
       *   c -= b;  c ^= rot(b, 8);  b += a; \
       *   a -= c;  a ^= rot(c,16);  c += b; \
       *   b -= a;  b ^= rot(a,19);  a += c; \
       *   c -= b;  c ^= rot(b, 4);  b += a; \
       * }
       * 
       * mix(a,b,c);
       */
      a = (a - c) & INT_MASK;  a ^= rot(c, 4);  c = (c + b) & INT_MASK;
      b = (b - a) & INT_MASK;  b ^= rot(a, 6);  a = (a + c) & INT_MASK;
      c = (c - b) & INT_MASK;  c ^= rot(b, 8);  b = (b + a) & INT_MASK;
      a = (a - c) & INT_MASK;  a ^= rot(c,16);  c = (c + b) & INT_MASK;
      b = (b - a) & INT_MASK;  b ^= rot(a,19);  a = (a + c) & INT_MASK;
      c = (c - b) & INT_MASK;  c ^= rot(b, 4);  b = (b + a) & INT_MASK;
    }

    //-------------------------------- last block: affect all 32 bits of (c)
    switch (length) {                   // all the case statements fall through
    case 12:
      c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
    case 11:
      c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
    case 10:
      c = (c + (((key[offset + 9]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
    case  9:
      c = (c + (key[offset + 8]    & BYTE_MASK)) & INT_MASK;
    case  8:
      b = (b + (((key[offset + 7]  & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
    case  7:
      b = (b + (((key[offset + 6]  & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
    case  6:
      b = (b + (((key[offset + 5]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
    case  5:
      b = (b + (key[offset + 4]    & BYTE_MASK)) & INT_MASK;
    case  4:
      a = (a + (((key[offset + 3]  & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
    case  3:
      a = (a + (((key[offset + 2]  & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
    case  2:
      a = (a + (((key[offset + 1]  & BYTE_MASK) <<  8) & INT_MASK)) & INT_MASK;
    case  1:
      a = (a + (key[offset + 0]    & BYTE_MASK)) & INT_MASK;
      break;
    case  0:
      return (int)(c & INT_MASK);
    }
    /*
     * final -- final mixing of 3 32-bit values (a,b,c) into c
     * 
     * Pairs of (a,b,c) values differing in only a few bits will usually
     * produce values of c that look totally different.  This was tested for
     * - pairs that differed by one bit, by two bits, in any combination
     *   of top bits of (a,b,c), or in any combination of bottom bits of
     *   (a,b,c).
     * 
     * - "differ" is defined as +, -, ^, or ~^.  For + and -, I transformed
     *   the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
     *   is commonly produced by subtraction) look like a single 1-bit
     *   difference.
     * 
     * - the base values were pseudorandom, all zero but one bit set, or
     *   all zero plus a counter that starts at zero.
     * 
     * These constants passed:
     *   14 11 25 16 4 14 24
     *   12 14 25 16 4 14 24
     * and these came close:
     *    4  8 15 26 3 22 24
     *   10  8 15 26 3 22 24
     *   11  8 15 26 3 22 24
     * 
     * #define final(a,b,c) \
     * { 
     *   c ^= b; c -= rot(b,14); \
     *   a ^= c; a -= rot(c,11); \
     *   b ^= a; b -= rot(a,25); \
     *   c ^= b; c -= rot(b,16); \
     *   a ^= c; a -= rot(c,4);  \
     *   b ^= a; b -= rot(a,14); \
     *   c ^= b; c -= rot(b,24); \
     * }
     * 
     */
    c ^= b; c = (c - rot(b,14)) & INT_MASK;
    a ^= c; a = (a - rot(c,11)) & INT_MASK;
    b ^= a; b = (b - rot(a,25)) & INT_MASK;
    c ^= b; c = (c - rot(b,16)) & INT_MASK;
    a ^= c; a = (a - rot(c,4))  & INT_MASK;
    b ^= a; b = (b - rot(a,14)) & INT_MASK;
    c ^= b; c = (c - rot(b,24)) & INT_MASK;

    return (int)(c & INT_MASK);
  }
  
  /**
   * Compute the hash of the specified file
   * @param args name of file to compute hash of.
   * @throws IOException
   */
  public static void main(String[] args) throws IOException {
    if (args.length != 1) {
      System.err.println("Usage: JenkinsHash filename");
      System.exit(-1);
    }
    FileInputStream in = new FileInputStream(args[0]);
    byte[] bytes = new byte[512];
    int value = 0;
    for (int length = in.read(bytes); length > 0 ; length = in.read(bytes)) {
      value = hash(bytes, length, value);
    }
    System.out.println(Math.abs(value));
  }
}
1	jimk	590875	/**
2			* Copyright 2007 The Apache Software Foundation
3			*
4			* Licensed to the Apache Software Foundation (ASF) under one
5			* or more contributor license agreements. See the NOTICE file
6			* distributed with this work for additional information
7			* regarding copyright ownership. The ASF licenses this file
8			* to you under the Apache License, Version 2.0 (the
9			* "License"); you may not use this file except in compliance
10			* with the License. You may obtain a copy of the License at
11			*
12			* http://www.apache.org/licenses/LICENSE-2.0
13			*
14			* Unless required by applicable law or agreed to in writing, software
15			* distributed under the License is distributed on an "AS IS" BASIS,
16			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17			* See the License for the specific language governing permissions and
18			* limitations under the License.
19			*/
20
21			package org.apache.hadoop.hbase.util;
22
23	jimk	639775	import java.io.FileInputStream;
24			import java.io.IOException;
25
26	jimk	590875	/**
27	stack	656868	* Produces 32-bit hash for hash table lookup.
28			*
29			* <pre>lookup3.c, by Bob Jenkins, May 2006, Public Domain.
30	jimk	590875	*
31			* You can use this free for any purpose. It's in the public domain.
32			* It has no warranty.
33	stack	656868	* </pre>
34	jimk	590875	*
35	stack	656868	* @see <a href="http://burtleburtle.net/bob/c/lookup3.c">lookup3.c</a>
36			* @see <a href="http://www.ddj.com/184410284">Hash Functions (and how this
37			* function compares to others such as CRC, MD?, etc</a>
38			* @see <a href="http://burtleburtle.net/bob/hash/doobs.html">Has update on the
39			* Dr. Dobbs Article</a>
40	jimk	590875	*/
41			public class JenkinsHash {
42			private static long INT_MASK = 0x00000000ffffffffL;
43			private static long BYTE_MASK = 0x00000000000000ffL;
44
45			private static long rot(long val, int pos) {
46	jimk	693597	return ((Integer.rotateLeft(
47	stack	689888	(int)(val & INT_MASK), pos)) & INT_MASK);
48	jimk	590875	}
49
50			/**
51			* Alternate form for hashing an entire byte array
52			*
53	stack	656868	* @param bytes
54			* @return hash value
55			*/
56			public static int hash(byte[] bytes) {
57			return hash(bytes, bytes.length, -1);
58			}
59
60			/**
61			* Alternate form for hashing an entire byte array
62			*
63	jimk	590875	* @param bytes
64			* @param initval
65			* @return hash value
66			*/
67			public static int hash(byte[] bytes, int initval) {
68			return hash(bytes, bytes.length, initval);
69			}
70
71			/**
72			* taken from hashlittle() -- hash a variable-length key into a 32-bit value
73			*
74			* @param key the key (the unaligned variable-length array of bytes)
75			* @param nbytes number of bytes to include in hash
76			* @param initval can be any integer value
77			* @return a 32-bit value. Every bit of the key affects every bit of the
78			* return value. Two keys differing by one or two bits will have totally
79			* different hash values.
80			*
81	stack	656868	* <p>The best hash table sizes are powers of 2. There is no need to do mod
82			* a prime (mod is sooo slow!). If you need less than 32 bits, use a bitmask.
83			* For example, if you need only 10 bits, do
84			* <code>h = (h & hashmask(10));</code>
85	jimk	590875	* In which case, the hash table should have hashsize(10) elements.
86			*
87	stack	656868	* <p>If you are hashing n strings byte[][] k, do it like this:
88	jimk	590875	* for (int i = 0, h = 0; i < n; ++i) h = hash( k[i], h);
89			*
90	stack	656868	* <p>By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
91	jimk	590875	* code any way you wish, private, educational, or commercial. It's free.
92			*
93	stack	656868	* <p>Use for hash table lookup, or anything where one collision in 2^^32 is
94	jimk	590875	* acceptable. Do NOT use for cryptographic purposes.
95			*/
96	jimk	693597	@SuppressWarnings("fallthrough")
97	jimk	590875	public static int hash(byte[] key, int nbytes, int initval) {
98			int length = nbytes;
99			long a, b, c; // We use longs because we don't have unsigned ints
100			a = b = c = (0x00000000deadbeefL + length + initval) & INT_MASK;
101			int offset = 0;
102			for (; length > 12; offset += 12, length -= 12) {
103			a = (a + (key[offset + 0] & BYTE_MASK)) & INT_MASK;
104			a = (a + (((key[offset + 1] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
105			a = (a + (((key[offset + 2] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
106			a = (a + (((key[offset + 3] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
107			b = (b + (key[offset + 4] & BYTE_MASK)) & INT_MASK;
108			b = (b + (((key[offset + 5] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
109			b = (b + (((key[offset + 6] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
110			b = (b + (((key[offset + 7] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
111			c = (c + (key[offset + 8] & BYTE_MASK)) & INT_MASK;
112			c = (c + (((key[offset + 9] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
113			c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
114			c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
115
116			/*
117			* mix -- mix 3 32-bit values reversibly.
118			* This is reversible, so any information in (a,b,c) before mix() is
119			* still in (a,b,c) after mix().
120			*
121			* If four pairs of (a,b,c) inputs are run through mix(), or through
122			* mix() in reverse, there are at least 32 bits of the output that
123			* are sometimes the same for one pair and different for another pair.
124			*
125			* This was tested for:
126			* - pairs that differed by one bit, by two bits, in any combination
127			* of top bits of (a,b,c), or in any combination of bottom bits of
128			* (a,b,c).
129			* - "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
130			* the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
131			* is commonly produced by subtraction) look like a single 1-bit
132			* difference.
133			* - the base values were pseudorandom, all zero but one bit set, or
134			* all zero plus a counter that starts at zero.
135			*
136			* Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
137			* satisfy this are
138			* 4 6 8 16 19 4
139			* 9 15 3 18 27 15
140			* 14 9 3 7 17 3
141			* Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing for
142			* "differ" defined as + with a one-bit base and a two-bit delta. I
143			* used http://burtleburtle.net/bob/hash/avalanche.html to choose
144			* the operations, constants, and arrangements of the variables.
145			*
146			* This does not achieve avalanche. There are input bits of (a,b,c)
147			* that fail to affect some output bits of (a,b,c), especially of a.
148			* The most thoroughly mixed value is c, but it doesn't really even
149			* achieve avalanche in c.
150			*
151			* This allows some parallelism. Read-after-writes are good at doubling
152			* the number of bits affected, so the goal of mixing pulls in the
153			* opposite direction as the goal of parallelism. I did what I could.
154			* Rotates seem to cost as much as shifts on every machine I could lay
155			* my hands on, and rotates are much kinder to the top and bottom bits,
156			* so I used rotates.
157			*
158			* #define mix(a,b,c) \
159			* { \
160			* a -= c; a ^= rot(c, 4); c += b; \
161			* b -= a; b ^= rot(a, 6); a += c; \
162			* c -= b; c ^= rot(b, 8); b += a; \
163			* a -= c; a ^= rot(c,16); c += b; \
164			* b -= a; b ^= rot(a,19); a += c; \
165			* c -= b; c ^= rot(b, 4); b += a; \
166			* }
167			*
168			* mix(a,b,c);
169			*/
170			a = (a - c) & INT_MASK; a ^= rot(c, 4); c = (c + b) & INT_MASK;
171			b = (b - a) & INT_MASK; b ^= rot(a, 6); a = (a + c) & INT_MASK;
172			c = (c - b) & INT_MASK; c ^= rot(b, 8); b = (b + a) & INT_MASK;
173			a = (a - c) & INT_MASK; a ^= rot(c,16); c = (c + b) & INT_MASK;
174			b = (b - a) & INT_MASK; b ^= rot(a,19); a = (a + c) & INT_MASK;
175			c = (c - b) & INT_MASK; c ^= rot(b, 4); b = (b + a) & INT_MASK;
176			}
177
178			//-------------------------------- last block: affect all 32 bits of (c)
179			switch (length) { // all the case statements fall through
180			case 12:
181			c = (c + (((key[offset + 11] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
182			case 11:
183			c = (c + (((key[offset + 10] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
184			case 10:
185			c = (c + (((key[offset + 9] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
186			case 9:
187			c = (c + (key[offset + 8] & BYTE_MASK)) & INT_MASK;
188			case 8:
189			b = (b + (((key[offset + 7] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
190			case 7:
191			b = (b + (((key[offset + 6] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
192			case 6:
193			b = (b + (((key[offset + 5] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
194			case 5:
195			b = (b + (key[offset + 4] & BYTE_MASK)) & INT_MASK;
196			case 4:
197			a = (a + (((key[offset + 3] & BYTE_MASK) << 24) & INT_MASK)) & INT_MASK;
198			case 3:
199			a = (a + (((key[offset + 2] & BYTE_MASK) << 16) & INT_MASK)) & INT_MASK;
200			case 2:
201			a = (a + (((key[offset + 1] & BYTE_MASK) << 8) & INT_MASK)) & INT_MASK;
202			case 1:
203			a = (a + (key[offset + 0] & BYTE_MASK)) & INT_MASK;
204			break;
205			case 0:
206	stack	689888	return (int)(c & INT_MASK);
207	jimk	590875	}
208			/*
209			* final -- final mixing of 3 32-bit values (a,b,c) into c
210			*
211			* Pairs of (a,b,c) values differing in only a few bits will usually
212			* produce values of c that look totally different. This was tested for
213			* - pairs that differed by one bit, by two bits, in any combination
214			* of top bits of (a,b,c), or in any combination of bottom bits of
215			* (a,b,c).
216			*
217			* - "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
218			* the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
219			* is commonly produced by subtraction) look like a single 1-bit
220			* difference.
221			*
222			* - the base values were pseudorandom, all zero but one bit set, or
223			* all zero plus a counter that starts at zero.
224			*
225			* These constants passed:
226			* 14 11 25 16 4 14 24
227			* 12 14 25 16 4 14 24
228			* and these came close:
229			* 4 8 15 26 3 22 24
230			* 10 8 15 26 3 22 24
231			* 11 8 15 26 3 22 24
232			*
233			* #define final(a,b,c) \
234			* {
235			* c ^= b; c -= rot(b,14); \
236			* a ^= c; a -= rot(c,11); \
237			* b ^= a; b -= rot(a,25); \
238			* c ^= b; c -= rot(b,16); \
239			* a ^= c; a -= rot(c,4); \
240			* b ^= a; b -= rot(a,14); \
241			* c ^= b; c -= rot(b,24); \
242			* }
243			*
244			*/
245			c ^= b; c = (c - rot(b,14)) & INT_MASK;
246			a ^= c; a = (a - rot(c,11)) & INT_MASK;
247			b ^= a; b = (b - rot(a,25)) & INT_MASK;
248			c ^= b; c = (c - rot(b,16)) & INT_MASK;
249			a ^= c; a = (a - rot(c,4)) & INT_MASK;
250			b ^= a; b = (b - rot(a,14)) & INT_MASK;
251			c ^= b; c = (c - rot(b,24)) & INT_MASK;
252
253	stack	689888	return (int)(c & INT_MASK);
254	jimk	590875	}
255	jimk	639775
256			/**
257			* Compute the hash of the specified file
258			* @param args name of file to compute hash of.
259			* @throws IOException
260			*/
261			public static void main(String[] args) throws IOException {
262			if (args.length != 1) {
263			System.err.println("Usage: JenkinsHash filename");
264			System.exit(-1);
265			}
266			FileInputStream in = new FileInputStream(args[0]);
267			byte[] bytes = new byte[512];
268			int value = 0;
269			for (int length = in.read(bytes); length > 0 ; length = in.read(bytes)) {
270			value = hash(bytes, length, value);
271			}
272			System.out.println(Math.abs(value));
273			}
274	jimk	590875	}