Hashes a value quick and dirty.

@param {*} it - A value to hash.
@returns {Number}
193461
function hashValue(it) {
	const str = JSON.stringify(it) || '';
	let hash = 5381;
	let i = str.length;
	while (i) {
		hash = hash * 33 ^ str.charCodeAt(--i);
	}
	return hash >>> 0;
}
447326
function version_1(input){
	var hash = BigInteger('14695981039346656037', 10); //offset: 14695981039346656037=0xcbf29ce484222325

	for(var i=0; i< input.length; i++){
		hash = hash.multiply(getPrime())
			.xor(BigInteger(input.charCodeAt(i)))
			.and(getMask());
	}

	return hash;
}
989297
function getShash() {
  const type = NodeType.ShashType;
  const token = tokens[pos];
  const line = token.ln;
  const column = token.col;
  const content = [];

  // Skip `#`.
  pos++;

  if (checkInterpolatedVariable(pos)) content.push(getInterpolatedVariable());
  else content.push(getIdent());

  return newNode(type, content, line, column);
}
629460
function hashToInts(hash) {
  var arr = []
  var num = 4

  for (var i = 0; i < 4; i++) {
    var part = hash.substr(i*8,8)
    var n = parseInt(part, 16) & 0x7fffffff
    arr.push(n)
  }

  return arr

}
580278
def hash(value, chars=None):
	''
	value = hash_func(value).hexdigest()
	if chars: value = value[:chars]
	return mark_safe(value)
784362
function serializeHash() {
      var hash = {}
      eachFormElement.apply(function (name, value) {
        if (name in hash) {
          hash[name] && !isArray(hash[name]) && (hash[name] = [hash[name]])
          hash[name].push(value)
        } else hash[name] = value
      }, arguments)
      return hash
    }
551316
function hashCode() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i - 0] = arguments[_i];
    }
    var hash = 0;
    for (var i = 0; i < args.length; ++i) {
        var str = args[i] || '';
        for (var j = 0, l = str.length; j < l; ++j) {
            var char = str.charCodeAt(j);
            hash = ((hash << 5) - hash) + char;
            hash |= 0; // Convert to 32bit integer
        }
    }
    return hash;
}
393912
function() {
        var v = this.__values__;
        if (this.____dirtyValues____ && Array.from(this.____dirtyValues____).length > 0) {
            for (var k in this.__dirtyValues__) {
                v[k] = this.__dirtyValues__[k];
            }
        }
        v.ID = this.getID();
        return v;
    }
419375
def hash(value):
    ''''''
    if not value:
        return
    elif len(value) == 32:
        type = 'md5'
    elif len(value) == 40:
        type = 'sha1'
    elif len(value) == 64:
        type = 'sha256'
    else:
        return None
    return {'type': type, 'value': value}
929104
public int hash() {
		hash ^= 4 * count;
		hash ^= hash >>> 16;
		hash *= 0x85ebca6b;
		hash ^= hash >>> 13;
		hash *= 0xc2b2ae35;
		hash ^= hash >>> 16;

		return hash;
	}
674281
def hash(self):
        '''
        
        '''
        if self._hash is None:
            self._initialize()
            self._hash = khash(type(self).__name__, self._default_value, self._fuzzable)
        return self._hash
474563
def hash(self):
        '''
        
        '''
        hashed = super(Conditional, self).hash()
        return khash(hashed, self._condition.hash())
351899
function getOrderIndependentHash(object) {
    var accum = 0;
    var type = realTypeOf(object);

    if (type === 'array') {
      object.forEach(function (item) {
        // Addition is commutative so this is order indep
        accum += getOrderIndependentHash(item);
      });

      var arrayString = '[type: array, hash: ' + accum + ']';
      return accum + hashThisString(arrayString);
    }

    if (type === 'object') {
      for (var key in object) {
        if (object.hasOwnProperty(key)) {
          var keyValueString = '[ type: object, key: ' + key + ', value hash: ' + getOrderIndependentHash(object[key]) + ']';
          accum += hashThisString(keyValueString);
        }
      }

      return accum;
    }

    // Non object, non array...should be good?
    var stringToHash = '[ type: ' + type + ' ; value: ' + object + ']';
    return accum + hashThisString(stringToHash);
  }
922968
function getHash (data, depth, index) {
    let element
    let elementsHash

    if (depth !== 0 && (depth + 1) !== height) {
      throw new Error('Value node is on wrong height in tree.')
    }

    if (start.gt(index) || end.lt(index)) {
      throw new Error('Wrong index of value node.')
    }

    if (start.plus(elements.length).neq(index)) {
      throw new Error('Value node is on wrong position in tree.')
    }

    if (typeof data === 'string') {
      if (!validateHexadecimal(data)) {
        throw new TypeError('Tree element of wrong type is passed. Hexadecimal expected.')
      }
      element = data
      elementsHash = element
    } else {
      if (Array.isArray(data)) {
        if (!validateBytesArray(data)) {
          throw new TypeError('Tree element of wrong type is passed. Bytes array expected.')
        }
        element = data.slice(0) // clone array of 8-bit integers
        elementsHash = hash(element)
      } else {
        if (!isObject(data)) {
          throw new TypeError('Invalid value of data parameter.')
        }
        if (!isType(type)) {
          throw new TypeError('Invalid type of type parameter.')
        }
        element = data
        elementsHash = hash(element, type)
      }
    }

    elements.push(element)
    return elementsHash
  }
903309
function iter (block) {
    var hash = crypto.createHash(opts.digest || 'md5')
    hash.update(block)
    hash.update(data)
    hash.update(salt)
    block = hash.digest()

    for (var i = 1; i < (opts.count || 1); i++) {
      hash = crypto.createHash(opts.digest || 'md5')
      hash.update(block)
      block = hash.digest()
    }

    return block
  }
997663
private int _hashCode(Object values) {
        int valueHash = 0;
        if (values instanceof Object[])
            valueHash = Arrays.deepHashCode((Object[]) values);
        else if (values instanceof byte[])
            valueHash = Arrays.hashCode((byte[]) values);
        else if (values instanceof short[])
            valueHash = Arrays.hashCode((short[]) values);
        else if (values instanceof int[])
            valueHash = Arrays.hashCode((int[]) values);
        else if (values instanceof long[])
            valueHash = Arrays.hashCode((long[]) values);
        else if (values instanceof char[])
            valueHash = Arrays.hashCode((char[]) values);
        else if (values instanceof float[])
            valueHash = Arrays.hashCode((float[]) values);
        else if (values instanceof double[])
            valueHash = Arrays.hashCode((double[]) values);
        else if (values instanceof boolean[])
            valueHash = Arrays.hashCode((boolean[]) values);
        else if (values != null)
            valueHash = values.hashCode();
        return valueHash;
    }
339159
function hash(s) {
    var h = hash.BASE

    for (var i = 0, l = s.length; i < l; i++) {
        h ^= s.charCodeAt(i)
        h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)
    }

    return h >>> 0
}