diff --git a/base/char.jl b/base/char.jl
index 2e8410f6903e2..7f4f5559927bd 100644
--- a/base/char.jl
+++ b/base/char.jl
@@ -220,7 +220,7 @@ in(x::AbstractChar, y::AbstractChar) = x == y
 ==(x::Char, y::Char) = bitcast(UInt32, x) == bitcast(UInt32, y)
 isless(x::Char, y::Char) = bitcast(UInt32, x) < bitcast(UInt32, y)
 hash(x::Char, h::UInt) =
-    hash_uint64(((bitcast(UInt32, x) + UInt64(0xd4d64234)) << 32) ⊻ UInt64(h))
+    hash_uint(((bitcast(UInt32, x) + UInt64(0xd4d64234)) << 32) ⊻ UInt64(h))
 
 first_utf8_byte(c::Char) = (bitcast(UInt32, c) >> 24) % UInt8
 first_utf8_byte(c::AbstractChar) = first_utf8_byte(Char(c)::Char)
diff --git a/base/float.jl b/base/float.jl
index faded5cd5978c..aba5f9141d45b 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -717,7 +717,7 @@ See also: [`Inf`](@ref), [`iszero`](@ref), [`isfinite`](@ref), [`isnan`](@ref).
 isinf(x::Real) = !isnan(x) & !isfinite(x)
 isinf(x::IEEEFloat) = abs(x) === oftype(x, Inf)
 
-const hx_NaN = hash_uint64(reinterpret(UInt64, NaN))
+const hx_NaN = hash_uint(reinterpret(UInt64, NaN))
 function hash(x::Float64, h::UInt)
     # see comments on trunc and hash(Real, UInt)
     if typemin(Int64) <= x < typemax(Int64)
@@ -733,7 +733,7 @@ function hash(x::Float64, h::UInt)
     elseif isnan(x)
         return hx_NaN ⊻ h # NaN does not have a stable bit pattern
     end
-    return hash_uint64(bitcast(UInt64, x)) - 3h
+    return hash_uint(bitcast(UInt64, x)) - 3h
 end
 
 hash(x::Float32, h::UInt) = hash(Float64(x), h)
@@ -748,7 +748,7 @@ function hash(x::Float16, h::UInt)
     elseif isnan(x)
         return hx_NaN ⊻ h # NaN does not have a stable bit pattern
     end
-    return hash_uint64(bitcast(UInt64, Float64(x))) - 3h
+    return hash_uint(bitcast(UInt64, Float64(x))) - 3h
 end
 
 ## generic hashing for rational values ##
diff --git a/base/hashing.jl b/base/hashing.jl
index d4a6217de6edb..375ea5d9aae63 100644
--- a/base/hashing.jl
+++ b/base/hashing.jl
@@ -39,46 +39,11 @@ hash(x::Symbol) = objectid(x)
 
 ## core data hashing functions ##
 
-function hash_64_64(n::UInt64)
-    a::UInt64 = n
-    a = ~a + a << 21
-    a =  a ⊻ a >> 24
-    a =  a + a << 3 + a << 8
-    a =  a ⊻ a >> 14
-    a =  a + a << 2 + a << 4
-    a =  a ⊻ a >> 28
-    a =  a + a << 31
-    return a
-end
-
-function hash_64_32(n::UInt64)
-    a::UInt64 = n
-    a = ~a + a << 18
-    a =  a ⊻ a >> 31
-    a =  a * 21
-    a =  a ⊻ a >> 11
-    a =  a + a << 6
-    a =  a ⊻ a >> 22
-    return a % UInt32
-end
-
-function hash_32_32(n::UInt32)
-    a::UInt32 = n
-    a = a + 0x7ed55d16 + a << 12
-    a = a ⊻ 0xc761c23c ⊻ a >> 19
-    a = a + 0x165667b1 + a << 5
-    a = a + 0xd3a2646c ⊻ a << 9
-    a = a + 0xfd7046c5 + a << 3
-    a = a ⊻ 0xb55a4f09 ⊻ a >> 16
-    return a
-end
-
-if UInt === UInt64
-    hash_uint64(x::UInt64) = hash_64_64(x)
-    hash_uint(x::UInt)     = hash_64_64(x)
-else
-    hash_uint64(x::UInt64) = hash_64_32(x)
-    hash_uint(x::UInt)     = hash_32_32(x)
+function hash_uint(n::T) where {T <: Union{UInt64, UInt32}}
+    # random constants, last must be odd
+    n += 0xe391e8b4ff155ee5 % T
+    n ⊻= 0xb9d8ebf206d49927 % T
+    n *= 0xafa64689f53d9ee1 % T
 end
 
 ## efficient value-based hashing of integers ##