Godeps: bump github.com/ethereum/ethash

This fixes the build.

Godeps/Godeps.json

@@ -17,8 +17,8 @@
 		},
 		{
 			"ImportPath": "github.com/ethereum/ethash",
-			"Comment": "v17-23-g2561e13",
+			"Comment": "v17-63-gbca024b",
-			"Rev": "2561e1322a7e8e3d4a2cc903c44b1e96340bcb27"
+			"Rev": "bca024b0b30d83ec6798a5d4fa8c5fc6f937009a"
 		},
 		{
 			"ImportPath": "github.com/ethereum/serpent-go",

Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore

@@ -2,4 +2,9 @@
 .DS_Store
 */**/*un~
 .vagrant/
-cpp-build/
+*.pyc
+build/
+pyethash.egg-info/
+*.so
+*~
+*.swp

Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml

@@ -0,0 +1,6 @@
+before_install:
+        - sudo apt-get update -qq
+        - sudo apt-get install -qq wget cmake gcc bash libboost-test-dev nodejs python-pip python-dev
+        - sudo pip install virtualenv -q
+
+script: "./test/test.sh"

Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.2)
+cmake_minimum_required(VERSION 2.8.7)
 project(ethash)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
@@ -8,7 +8,8 @@ if (WIN32 AND WANT_CRYPTOPP)
 	add_subdirectory(cryptopp)
 endif()
 
-add_subdirectory(libethash)
+add_subdirectory(src/libethash)
-add_subdirectory(libethash-cl EXCLUDE_FROM_ALL)
+# bin2h.cmake doesn't work
-add_subdirectory(benchmark EXCLUDE_FROM_ALL)
+#add_subdirectory(src/libethash-cl EXCLUDE_FROM_ALL)
-add_subdirectory(test EXCLUDE_FROM_ALL)
+add_subdirectory(src/benchmark EXCLUDE_FROM_ALL)
+add_subdirectory(test/c EXCLUDE_FROM_ALL)

Godeps/_workspace/src/github.com/ethereum/ethash/Makefile

@@ -0,0 +1,3 @@
+.PHONY: clean
+clean:
+	rm -rf *.so pyethash.egg-info/ build/ test/python/python-virtual-env/ test/c/build/ pyethash/*.{so,pyc}

Godeps/_workspace/src/github.com/ethereum/ethash/README.md

@@ -0,0 +1,7 @@
+[![Build Status](https://travis-ci.org/ethereum/ethash.svg?branch=master)](https://travis-ci.org/ethereum/ethash)
+
+
+# Ethash
+
+For details on this project, please see the Ethereum wiki:
+https://github.com/ethereum/wiki/wiki/Ethash

Godeps/_workspace/src/github.com/ethereum/ethash/Vagrantfile

@@ -0,0 +1,7 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure(2) do |config|
+  config.vm.box = "Ubuntu 12.04"
+  config.vm.box_url = "https://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-amd64-vagrant-disk1.box"
+end

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake

@@ -0,0 +1,161 @@
+#.rst:
+# CMakeParseArguments
+# -------------------
+#
+#
+#
+# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords>
+# <multi_value_keywords> args...)
+#
+# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions
+# for parsing the arguments given to that macro or function.  It
+# processes the arguments and defines a set of variables which hold the
+# values of the respective options.
+#
+# The <options> argument contains all options for the respective macro,
+# i.e.  keywords which can be used when calling the macro without any
+# value following, like e.g.  the OPTIONAL keyword of the install()
+# command.
+#
+# The <one_value_keywords> argument contains all keywords for this macro
+# which are followed by one value, like e.g.  DESTINATION keyword of the
+# install() command.
+#
+# The <multi_value_keywords> argument contains all keywords for this
+# macro which can be followed by more than one value, like e.g.  the
+# TARGETS or FILES keywords of the install() command.
+#
+# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
+# keywords listed in <options>, <one_value_keywords> and
+# <multi_value_keywords> a variable composed of the given <prefix>
+# followed by "_" and the name of the respective keyword.  These
+# variables will then hold the respective value from the argument list.
+# For the <options> keywords this will be TRUE or FALSE.
+#
+# All remaining arguments are collected in a variable
+# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see
+# whether your macro was called with unrecognized parameters.
+#
+# As an example here a my_install() macro, which takes similar arguments
+# as the real install() command:
+#
+# ::
+#
+#    function(MY_INSTALL)
+#      set(options OPTIONAL FAST)
+#      set(oneValueArgs DESTINATION RENAME)
+#      set(multiValueArgs TARGETS CONFIGURATIONS)
+#      cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}"
+#                            "${multiValueArgs}" ${ARGN} )
+#      ...
+#
+#
+#
+# Assume my_install() has been called like this:
+#
+# ::
+#
+#    my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
+#
+#
+#
+# After the cmake_parse_arguments() call the macro will have set the
+# following variables:
+#
+# ::
+#
+#    MY_INSTALL_OPTIONAL = TRUE
+#    MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
+#    MY_INSTALL_DESTINATION = "bin"
+#    MY_INSTALL_RENAME = "" (was not used)
+#    MY_INSTALL_TARGETS = "foo;bar"
+#    MY_INSTALL_CONFIGURATIONS = "" (was not used)
+#    MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
+#
+#
+#
+# You can then continue and process these variables.
+#
+# Keywords terminate lists of values, e.g.  if directly after a
+# one_value_keyword another recognized keyword follows, this is
+# interpreted as the beginning of the new option.  E.g.
+# my_install(TARGETS foo DESTINATION OPTIONAL) would result in
+# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION
+# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+
+#=============================================================================
+# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
+  return()
+endif()
+set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
+
+
+function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
+  # first set all result variables to empty/FALSE
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
+    set(${prefix}_${arg_name})
+  endforeach()
+
+  foreach(option ${_optionNames})
+    set(${prefix}_${option} FALSE)
+  endforeach()
+
+  set(${prefix}_UNPARSED_ARGUMENTS)
+
+  set(insideValues FALSE)
+  set(currentArgName)
+
+  # now iterate over all arguments and fill the result variables
+  foreach(currentArg ${ARGN})
+    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+
+    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
+      if(insideValues)
+        if("${insideValues}" STREQUAL "SINGLE")
+          set(${prefix}_${currentArgName} ${currentArg})
+          set(insideValues FALSE)
+        elseif("${insideValues}" STREQUAL "MULTI")
+          list(APPEND ${prefix}_${currentArgName} ${currentArg})
+        endif()
+      else()
+        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
+      endif()
+    else()
+      if(NOT ${optionIndex} EQUAL -1)
+        set(${prefix}_${currentArg} TRUE)
+        set(insideValues FALSE)
+      elseif(NOT ${singleArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "SINGLE")
+      elseif(NOT ${multiArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "MULTI")
+      endif()
+    endif()
+
+  endforeach()
+
+  # propagate the result variables to the caller:
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
+    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
+  endforeach()
+  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
+
+endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake

@@ -1,91 +1,136 @@
+#.rst:
+# FindOpenCL
+# ----------
 #
-#  This file taken from FindOpenCL project @ http://gitorious.com/findopencl
+# Try to find OpenCL
 #
-# - Try to find OpenCL
+# Once done this will define::
-# This module tries to find an OpenCL implementation on your system. It supports
-# AMD / ATI, Apple and NVIDIA implementations, but shoudl work, too.
 #
-# Once done this will define
+#   OpenCL_FOUND          - True if OpenCL was found
-#  OPENCL_FOUND        - system has OpenCL
+#   OpenCL_INCLUDE_DIRS   - include directories for OpenCL
-#  OPENCL_INCLUDE_DIRS  - the OpenCL include directory
+#   OpenCL_LIBRARIES      - link against this library to use OpenCL
-#  OPENCL_LIBRARIES    - link these to use OpenCL
+#   OpenCL_VERSION_STRING - Highest supported OpenCL version (eg. 1.2)
+#   OpenCL_VERSION_MAJOR  - The major version of the OpenCL implementation
+#   OpenCL_VERSION_MINOR  - The minor version of the OpenCL implementation
+#
+# The module will also define two cache variables::
+#
+#   OpenCL_INCLUDE_DIR    - the OpenCL include directory
+#   OpenCL_LIBRARY        - the path to the OpenCL library
 #
-# WIN32 should work, but is untested
 
-FIND_PACKAGE( PackageHandleStandardArgs )
+#=============================================================================
+# Copyright 2014 Matthaeus G. Chajdas
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
 
-SET (OPENCL_VERSION_STRING "0.1.0")
+function(_FIND_OPENCL_VERSION)
-SET (OPENCL_VERSION_MAJOR 0)
+  include(CheckSymbolExists)
-SET (OPENCL_VERSION_MINOR 1)
+  include(CMakePushCheckState)
-SET (OPENCL_VERSION_PATCH 0)
+  set(CMAKE_REQUIRED_QUIET ${OpenCL_FIND_QUIETLY})
 
-IF (APPLE)
+  CMAKE_PUSH_CHECK_STATE()
+  foreach(VERSION "2_0" "1_2" "1_1" "1_0")
+    set(CMAKE_REQUIRED_INCLUDES "${OpenCL_INCLUDE_DIR}")
 
-  FIND_LIBRARY(OPENCL_LIBRARIES OpenCL DOC "OpenCL lib for OSX")
+    if(APPLE)
-  FIND_PATH(OPENCL_INCLUDE_DIRS OpenCL/cl.h DOC "Include for OpenCL on OSX")
+      CHECK_SYMBOL_EXISTS(
-  FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS OpenCL/cl.hpp DOC "Include for OpenCL CPP bindings on OSX")
+        CL_VERSION_${VERSION}
+        "${OpenCL_INCLUDE_DIR}/OpenCL/cl.h"
+        OPENCL_VERSION_${VERSION})
+    else()
+      CHECK_SYMBOL_EXISTS(
+        CL_VERSION_${VERSION}
+        "${OpenCL_INCLUDE_DIR}/CL/cl.h"
+        OPENCL_VERSION_${VERSION})
+    endif()
 
-ELSE (APPLE)
+    if(OPENCL_VERSION_${VERSION})
+      string(REPLACE "_" "." VERSION "${VERSION}")
+      set(OpenCL_VERSION_STRING ${VERSION} PARENT_SCOPE)
+      string(REGEX MATCHALL "[0-9]+" version_components "${VERSION}")
+      list(GET version_components 0 major_version)
+      list(GET version_components 1 minor_version)
+      set(OpenCL_VERSION_MAJOR ${major_version} PARENT_SCOPE)
+      set(OpenCL_VERSION_MINOR ${minor_version} PARENT_SCOPE)
+      break()
+    endif()
+  endforeach()
+  CMAKE_POP_CHECK_STATE()
+endfunction()
 
-	IF (WIN32)
+find_path(OpenCL_INCLUDE_DIR
+  NAMES
+    CL/cl.h OpenCL/cl.h
+  PATHS
+    ENV "PROGRAMFILES(X86)"
+    ENV AMDAPPSDKROOT
+    ENV INTELOCLSDKROOT
+    ENV NVSDKCOMPUTE_ROOT
+    ENV CUDA_PATH
+    ENV ATISTREAMSDKROOT
+  PATH_SUFFIXES
+    include
+    OpenCL/common/inc
+    "AMD APP/include")
 
-	    FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h)
+_FIND_OPENCL_VERSION()
-	    FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp)
 
-	    # The AMD SDK currently installs both x86 and x86_64 libraries
+if(WIN32)
-	    # This is only a hack to find out architecture
+  if(CMAKE_SIZEOF_VOID_P EQUAL 4)
-	    IF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
+    find_library(OpenCL_LIBRARY
-	    	SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86_64")
+      NAMES OpenCL
-			SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86_64")
+      PATHS
-	    ELSE (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64")
+        ENV "PROGRAMFILES(X86)"
-	    	SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86")
+        ENV AMDAPPSDKROOT
-	   		SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86")
+        ENV INTELOCLSDKROOT
-	    ENDIF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" )
+        ENV CUDA_PATH
+        ENV NVSDKCOMPUTE_ROOT
+        ENV ATISTREAMSDKROOT
+      PATH_SUFFIXES
+        "AMD APP/lib/x86"
+        lib/x86
+        lib/Win32
+        OpenCL/common/lib/Win32)
+  elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    find_library(OpenCL_LIBRARY
+      NAMES OpenCL
+      PATHS
+        ENV "PROGRAMFILES(X86)"
+        ENV AMDAPPSDKROOT
+        ENV INTELOCLSDKROOT
+        ENV CUDA_PATH
+        ENV NVSDKCOMPUTE_ROOT
+        ENV ATISTREAMSDKROOT
+      PATH_SUFFIXES
+        "AMD APP/lib/x86_64"
+        lib/x86_64
+        lib/x64
+        OpenCL/common/lib/x64)
+  endif()
+else()
+  find_library(OpenCL_LIBRARY
+    NAMES OpenCL)
+endif()
 
-	    # find out if the user asked for a 64-bit build, and use the corresponding 
+set(OpenCL_LIBRARIES ${OpenCL_LIBRARY})
-	    # 64 or 32 bit NVIDIA library paths to the search:
+set(OpenCL_INCLUDE_DIRS ${OpenCL_INCLUDE_DIR})
-	    STRING(REGEX MATCH "Win64" ISWIN64 ${CMAKE_GENERATOR})
-	    IF("${ISWIN64}" STREQUAL "Win64") 
-	    	FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/x64)
-	    ELSE("${ISWIN64}" STREQUAL "Win64") 
-	    	FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/Win32)
-	    ENDIF("${ISWIN64}" STREQUAL "Win64") 
 
-	    GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+find_package_handle_standard_args(
+  OpenCL
+  FOUND_VAR OpenCL_FOUND
+  REQUIRED_VARS OpenCL_LIBRARY OpenCL_INCLUDE_DIR
+  VERSION_VAR OpenCL_VERSION_STRING)
 
-	    # On Win32 search relative to the library
+mark_as_advanced(
-	    FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)
+  OpenCL_INCLUDE_DIR
-	    FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include)
+  OpenCL_LIBRARY)
-	
-	ELSE (WIN32)
-
-            # Unix style platforms
-            FIND_LIBRARY(OPENCL_LIBRARIES OpenCL
-              ENV LD_LIBRARY_PATH
-            )
-
-            GET_FILENAME_COMPONENT(OPENCL_LIB_DIR ${OPENCL_LIBRARIES} PATH)
-            GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE)
-
-            # The AMD SDK currently does not place its headers
-            # in /usr/include, therefore also search relative
-            # to the library
-            FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include")
-            FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include")
-
-	ENDIF (WIN32)
-
-ENDIF (APPLE)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS( OpenCL DEFAULT_MSG OPENCL_LIBRARIES OPENCL_INCLUDE_DIRS )
-
-IF( _OPENCL_CPP_INCLUDE_DIRS )
-	SET( OPENCL_HAS_CPP_BINDINGS TRUE )
-	LIST( APPEND OPENCL_INCLUDE_DIRS ${_OPENCL_CPP_INCLUDE_DIRS} )
-	# This is often the same, so clean up
-	LIST( REMOVE_DUPLICATES OPENCL_INCLUDE_DIRS )
-ENDIF( _OPENCL_CPP_INCLUDE_DIRS )
-
-MARK_AS_ADVANCED(
-  OPENCL_INCLUDE_DIRS
-)

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake

@@ -0,0 +1,382 @@
+#.rst:
+# FindPackageHandleStandardArgs
+# -----------------------------
+#
+#
+#
+# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ...  )
+#
+# This function is intended to be used in FindXXX.cmake modules files.
+# It handles the REQUIRED, QUIET and version-related arguments to
+# find_package().  It also sets the <packagename>_FOUND variable.  The
+# package is considered found if all variables <var1>...  listed contain
+# valid results, e.g.  valid filepaths.
+#
+# There are two modes of this function.  The first argument in both
+# modes is the name of the Find-module where it is called (in original
+# casing).
+#
+# The first simple mode looks like this:
+#
+# ::
+#
+#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name>
+#       (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )
+#
+# If the variables <var1> to <varN> are all valid, then
+# <UPPERCASED_NAME>_FOUND will be set to TRUE.  If DEFAULT_MSG is given
+# as second argument, then the function will generate itself useful
+# success and error messages.  You can also supply a custom error
+# message for the failure case.  This is not recommended.
+#
+# The second mode is more powerful and also supports version checking:
+#
+# ::
+#
+#     FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME
+#       [FOUND_VAR <resultVar>]
+#       [REQUIRED_VARS <var1>...<varN>]
+#       [VERSION_VAR   <versionvar>]
+#       [HANDLE_COMPONENTS]
+#       [CONFIG_MODE]
+#       [FAIL_MESSAGE "Custom failure message"] )
+#
+# In this mode, the name of the result-variable can be set either to
+# either <UPPERCASED_NAME>_FOUND or <OriginalCase_Name>_FOUND using the
+# FOUND_VAR option.  Other names for the result-variable are not
+# allowed.  So for a Find-module named FindFooBar.cmake, the two
+# possible names are FooBar_FOUND and FOOBAR_FOUND.  It is recommended
+# to use the original case version.  If the FOUND_VAR option is not
+# used, the default is <UPPERCASED_NAME>_FOUND.
+#
+# As in the simple mode, if <var1> through <varN> are all valid,
+# <packagename>_FOUND will be set to TRUE.  After REQUIRED_VARS the
+# variables which are required for this package are listed.  Following
+# VERSION_VAR the name of the variable can be specified which holds the
+# version of the package which has been found.  If this is done, this
+# version will be checked against the (potentially) specified required
+# version used in the find_package() call.  The EXACT keyword is also
+# handled.  The default messages include information about the required
+# version and the version which has been actually found, both if the
+# version is ok or not.  If the package supports components, use the
+# HANDLE_COMPONENTS option to enable handling them.  In this case,
+# find_package_handle_standard_args() will report which components have
+# been found and which are missing, and the <packagename>_FOUND variable
+# will be set to FALSE if any of the required components (i.e.  not the
+# ones listed after OPTIONAL_COMPONENTS) are missing.  Use the option
+# CONFIG_MODE if your FindXXX.cmake module is a wrapper for a
+# find_package(...  NO_MODULE) call.  In this case VERSION_VAR will be
+# set to <NAME>_VERSION and the macro will automatically check whether
+# the Config module was found.  Via FAIL_MESSAGE a custom failure
+# message can be specified, if this is not used, the default message
+# will be displayed.
+#
+# Example for mode 1:
+#
+# ::
+#
+#     find_package_handle_standard_args(LibXml2  DEFAULT_MSG
+#       LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
+#
+#
+#
+# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and
+# LIBXML2_INCLUDE_DIR are valid.  Then also LIBXML2_FOUND is set to
+# TRUE.  If it is not found and REQUIRED was used, it fails with
+# FATAL_ERROR, independent whether QUIET was used or not.  If it is
+# found, success will be reported, including the content of <var1>.  On
+# repeated Cmake runs, the same message won't be printed again.
+#
+# Example for mode 2:
+#
+# ::
+#
+#     find_package_handle_standard_args(LibXslt
+#       FOUND_VAR LibXslt_FOUND
+#       REQUIRED_VARS LibXslt_LIBRARIES LibXslt_INCLUDE_DIRS
+#       VERSION_VAR LibXslt_VERSION_STRING)
+#
+# In this case, LibXslt is considered to be found if the variable(s)
+# listed after REQUIRED_VAR are all valid, i.e.  LibXslt_LIBRARIES and
+# LibXslt_INCLUDE_DIRS in this case.  The result will then be stored in
+# LibXslt_FOUND .  Also the version of LibXslt will be checked by using
+# the version contained in LibXslt_VERSION_STRING.  Since no
+# FAIL_MESSAGE is given, the default messages will be printed.
+#
+# Another example for mode 2:
+#
+# ::
+#
+#     find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
+#     find_package_handle_standard_args(Automoc4  CONFIG_MODE)
+#
+# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4
+# NO_MODULE) and adds an additional search directory for automoc4.  Here
+# the result will be stored in AUTOMOC4_FOUND.  The following
+# FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper
+# success/error message.
+
+#=============================================================================
+# Copyright 2007-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
+
+# internal helper macro
+macro(_FPHSA_FAILURE_MESSAGE _msg)
+  if (${_NAME}_FIND_REQUIRED)
+    message(FATAL_ERROR "${_msg}")
+  else ()
+    if (NOT ${_NAME}_FIND_QUIETLY)
+      message(STATUS "${_msg}")
+    endif ()
+  endif ()
+endmacro()
+
+
+# internal helper macro to generate the failure message when used in CONFIG_MODE:
+macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
+  # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
+  if(${_NAME}_CONFIG)
+    _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
+  else()
+    # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
+    # List them all in the error message:
+    if(${_NAME}_CONSIDERED_CONFIGS)
+      set(configsText "")
+      list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
+      math(EXPR configsCount "${configsCount} - 1")
+      foreach(currentConfigIndex RANGE ${configsCount})
+        list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
+        list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
+        set(configsText "${configsText}    ${filename} (version ${version})\n")
+      endforeach()
+      if (${_NAME}_NOT_FOUND_MESSAGE)
+        set(configsText "${configsText}    Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
+      endif()
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
+
+    else()
+      # Simple case: No Config-file was found at all:
+      _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
+    endif()
+  endif()
+endmacro()
+
+
+function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
+
+# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
+# new extended or in the "old" mode:
+  set(options  CONFIG_MODE  HANDLE_COMPONENTS)
+  set(oneValueArgs  FAIL_MESSAGE  VERSION_VAR  FOUND_VAR)
+  set(multiValueArgs REQUIRED_VARS)
+  set(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
+  list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
+
+  if(${INDEX} EQUAL -1)
+    set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
+    set(FPHSA_REQUIRED_VARS ${ARGN})
+    set(FPHSA_VERSION_VAR)
+  else()
+
+    CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${ARGN})
+
+    if(FPHSA_UNPARSED_ARGUMENTS)
+      message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+    if(NOT FPHSA_FAIL_MESSAGE)
+      set(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
+    endif()
+  endif()
+
+# now that we collected all arguments, process them
+
+  if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
+    set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
+  endif()
+
+  # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
+  # when it successfully found the config-file, including version checking:
+  if(FPHSA_CONFIG_MODE)
+    list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
+    list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
+    set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
+  endif()
+
+  if(NOT FPHSA_REQUIRED_VARS)
+    message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
+  endif()
+
+  list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
+
+  string(TOUPPER ${_NAME} _NAME_UPPER)
+  string(TOLOWER ${_NAME} _NAME_LOWER)
+
+  if(FPHSA_FOUND_VAR)
+    if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$"  OR  FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
+      set(_FOUND_VAR ${FPHSA_FOUND_VAR})
+    else()
+      message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
+    endif()
+  else()
+    set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
+  endif()
+
+  # collect all variables which were not found, so they can be printed, so the
+  # user knows better what went wrong (#6375)
+  set(MISSING_VARS "")
+  set(DETAILS "")
+  # check if all passed variables are valid
+  unset(${_FOUND_VAR})
+  foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
+    if(NOT ${_CURRENT_VAR})
+      set(${_FOUND_VAR} FALSE)
+      set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
+    else()
+      set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]")
+    endif()
+  endforeach()
+  if(NOT "${${_FOUND_VAR}}" STREQUAL "FALSE")
+    set(${_FOUND_VAR} TRUE)
+  endif()
+
+  # component handling
+  unset(FOUND_COMPONENTS_MSG)
+  unset(MISSING_COMPONENTS_MSG)
+
+  if(FPHSA_HANDLE_COMPONENTS)
+    foreach(comp ${${_NAME}_FIND_COMPONENTS})
+      if(${_NAME}_${comp}_FOUND)
+
+        if(NOT DEFINED FOUND_COMPONENTS_MSG)
+          set(FOUND_COMPONENTS_MSG "found components: ")
+        endif()
+        set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}")
+
+      else()
+
+        if(NOT DEFINED MISSING_COMPONENTS_MSG)
+          set(MISSING_COMPONENTS_MSG "missing components: ")
+        endif()
+        set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}")
+
+        if(${_NAME}_FIND_REQUIRED_${comp})
+          set(${_FOUND_VAR} FALSE)
+          set(MISSING_VARS "${MISSING_VARS} ${comp}")
+        endif()
+
+      endif()
+    endforeach()
+    set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
+    set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]")
+  endif()
+
+  # version handling:
+  set(VERSION_MSG "")
+  set(VERSION_OK TRUE)
+  set(VERSION ${${FPHSA_VERSION_VAR}})
+
+  # check with DEFINED here as the requested or found version may be "0"
+  if (DEFINED ${_NAME}_FIND_VERSION)
+    if(DEFINED ${FPHSA_VERSION_VAR})
+
+      if(${_NAME}_FIND_VERSION_EXACT)       # exact version required
+        # count the dots in the version string
+        string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}")
+        # add one dot because there is one dot more than there are components
+        string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
+        if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
+          # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
+          # is at most 4 here. Therefore a simple lookup table is used.
+          if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
+            set(_VERSION_REGEX "[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*")
+          elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
+          else ()
+            set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
+          endif ()
+          string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}")
+          unset(_VERSION_REGEX)
+          if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+          unset(_VERSION_HEAD)
+        else ()
+          if (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
+            set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            set(VERSION_OK FALSE)
+          else ()
+            set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
+          endif ()
+        endif ()
+        unset(_VERSION_DOTS)
+
+      else()     # minimum version specified:
+        if ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
+          set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
+          set(VERSION_OK FALSE)
+        else ()
+          set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
+        endif ()
+      endif()
+
+    else()
+
+      # if the package was not found, but a version was given, add that to the output:
+      if(${_NAME}_FIND_VERSION_EXACT)
+         set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
+      else()
+         set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
+      endif()
+
+    endif()
+  else ()
+    if(VERSION)
+      set(VERSION_MSG "(found version \"${VERSION}\")")
+    endif()
+  endif ()
+
+  if(VERSION_OK)
+    set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]")
+  else()
+    set(${_FOUND_VAR} FALSE)
+  endif()
+
+
+  # print the result:
+  if (${_FOUND_VAR})
+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
+  else ()
+
+    if(FPHSA_CONFIG_MODE)
+      _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
+    else()
+      if(NOT VERSION_OK)
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
+      else()
+        _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
+      endif()
+    endif()
+
+  endif ()
+
+  set(${_FOUND_VAR} ${${_FOUND_VAR}} PARENT_SCOPE)
+
+endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake

@@ -0,0 +1,57 @@
+#.rst:
+# FindPackageMessage
+# ------------------
+#
+#
+#
+# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
+#
+# This macro is intended to be used in FindXXX.cmake modules files.  It
+# will print a message once for each unique find result.  This is useful
+# for telling the user where a package was found.  The first argument
+# specifies the name (XXX) of the package.  The second argument
+# specifies the message to display.  The third argument lists details
+# about the find result so that if they change the message will be
+# displayed again.  The macro also obeys the QUIET argument to the
+# find_package command.
+#
+# Example:
+#
+# ::
+#
+#   if(X11_FOUND)
+#     FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
+#       "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
+#   else()
+#    ...
+#   endif()
+
+#=============================================================================
+# Copyright 2008-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+function(FIND_PACKAGE_MESSAGE pkg msg details)
+  # Avoid printing a message repeatedly for the same find result.
+  if(NOT ${pkg}_FIND_QUIETLY)
+    string(REPLACE "\n" "" details "${details}")
+    set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
+    if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
+      # The message has not yet been printed.
+      message(STATUS "${msg}")
+
+      # Save the find details in the cache to avoid printing the same
+      # message again.
+      set("${DETAILS_VAR}" "${details}"
+        CACHE INTERNAL "Details about finding ${pkg}")
+    endif()
+  endif()
+endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go

@@ -2,32 +2,39 @@ package ethash
 
 /*
 #cgo CFLAGS: -std=gnu99 -Wall
-#include "libethash/ethash.h"
+#include "src/libethash/util.c"
-#include "libethash/util.c"
+#include "src/libethash/internal.c"
-#include "libethash/internal.c"
+#include "src/libethash/sha3.c"
-#include "libethash/sha3.c"
 */
 import "C"
 
 import (
 	"bytes"
 	"encoding/binary"
+	"fmt"
+	"io/ioutil"
 	"log"
 	"math/big"
 	"math/rand"
+	"os"
+	"path"
 	"sync"
 	"time"
 	"unsafe"
 
+	"github.com/ethereum/go-ethereum/ethutil"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/pow"
 )
 
+var tt256 = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), big.NewInt(0))
+
 var powlogger = logger.NewLogger("POW")
 
 type DAG struct {
 	SeedBlockNum uint64
 	dag          unsafe.Pointer // full GB of memory for dag
+	file         bool
 }
 
 type ParamsAndCache struct {
@@ -59,16 +66,28 @@ func parseNonce(nonce []byte) (uint64, error) {
 
 const epochLength uint64 = 30000
 
-func getSeedBlockNum(blockNum uint64) uint64 {
+func GetSeedBlockNum(blockNum uint64) uint64 {
 	var seedBlockNum uint64 = 0
-	if blockNum >= 2*epochLength {
+	if blockNum > epochLength {
-		seedBlockNum = ((blockNum / epochLength) - 1) * epochLength
+		seedBlockNum = ((blockNum - 1) / epochLength) * epochLength
 	}
 	return seedBlockNum
 }
 
+/*
+XXX THIS DOESN'T WORK!! NEEDS FIXING
+blockEpoch will underflow and wrap around causing massive issues
+func GetSeedBlockNum(blockNum uint64) uint64 {
+	var seedBlockNum uint64 = 0
+	if blockNum > epochLength {
+		seedBlockNum = ((blockNum - 1) / epochLength) * epochLength
+	}
+	return seedBlockNum
+}
+*/
+
 func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) *ParamsAndCache {
-	seedBlockNum := getSeedBlockNum(blockNum)
+	seedBlockNum := GetSeedBlockNum(blockNum)
 	paramsAndCache := &ParamsAndCache{
 		params:       new(C.ethash_params),
 		cache:        new(C.ethash_cache),
@@ -76,19 +95,19 @@ func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) *ParamsA
 	}
 	C.ethash_params_init(paramsAndCache.params, C.uint32_t(seedBlockNum))
 	paramsAndCache.cache.mem = C.malloc(paramsAndCache.params.cache_size)
-	seedHash := chainManager.GetBlockByNumber(seedBlockNum).Header().Hash()
+	seedHash := chainManager.GetBlockByNumber(seedBlockNum).SeedHash()
-	log.Println("Params", paramsAndCache.params)
 
 	log.Println("Making Cache")
 	start := time.Now()
-	C.ethash_mkcache(paramsAndCache.cache, paramsAndCache.params, (*C.uint8_t)((unsafe.Pointer)(&seedHash[0])))
+	C.ethash_mkcache(paramsAndCache.cache, paramsAndCache.params, (*C.uint8_t)(unsafe.Pointer(&seedHash[0])))
 	log.Println("Took:", time.Since(start))
+
 	return paramsAndCache
 }
 
 func (pow *Ethash) updateCache() {
 	pow.cacheMutex.Lock()
-	seedNum := getSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64())
+	seedNum := GetSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64())
 	if pow.paramsAndCache.SeedBlockNum != seedNum {
 		pow.paramsAndCache = makeParamsAndCache(pow.chainManager, pow.chainManager.CurrentBlock().NumberU64())
 	}
@@ -104,17 +123,66 @@ func makeDAG(p *ParamsAndCache) *DAG {
 	return d
 }
 
-func (pow *Ethash) updateDAG() {
+func (pow *Ethash) writeDagToDisk(dag *DAG, seedNum uint64) *os.File {
+	data := C.GoBytes(unsafe.Pointer(dag.dag), C.int(pow.paramsAndCache.params.full_size))
+	file, err := os.Create("/tmp/dag")
+	if err != nil {
+		panic(err)
+	}
+
+	num := make([]byte, 8)
+	binary.BigEndian.PutUint64(num, seedNum)
+
+	file.Write(num)
+	file.Write(data)
+
+	return file
+}
+
+func (pow *Ethash) UpdateDAG() {
 	pow.cacheMutex.Lock()
 	pow.dagMutex.Lock()
 
-	seedNum := getSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64())
+	seedNum := GetSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64())
 	if pow.dag == nil || pow.dag.SeedBlockNum != seedNum {
+		if pow.dag != nil && pow.dag.dag != nil {
+			C.free(pow.dag.dag)
+			pow.dag.dag = nil
+		}
+
+		path := path.Join("/", "tmp", "dag")
 		pow.dag = nil
-		log.Println("Making Dag")
+		log.Println("Generating dag")
 		start := time.Now()
-		pow.dag = makeDAG(pow.paramsAndCache)
+
+		file, err := os.Open(path)
+		if err != nil {
+			log.Printf("No dag found in '%s'. Generating new dago(takes a while)...", path)
+			pow.dag = makeDAG(pow.paramsAndCache)
+			file = pow.writeDagToDisk(pow.dag, seedNum)
+		} else {
+			data, err := ioutil.ReadAll(file)
+			if err != nil {
+				panic(err)
+			}
+
+			num := binary.BigEndian.Uint64(data[0:8])
+			if num < seedNum {
+				log.Printf("Old found. Generating new dag (takes a while)...")
+				pow.dag = makeDAG(pow.paramsAndCache)
+				file = pow.writeDagToDisk(pow.dag, seedNum)
+			} else {
+				data = data[8:]
+				pow.dag = &DAG{
+					dag:          unsafe.Pointer(&data[0]),
+					file:         true,
+					SeedBlockNum: pow.paramsAndCache.SeedBlockNum,
+				}
+			}
+		}
 		log.Println("Took:", time.Since(start))
+
+		file.Close()
 	}
 
 	pow.dagMutex.Unlock()
@@ -123,11 +191,10 @@ func (pow *Ethash) updateDAG() {
 
 func New(chainManager pow.ChainManager) *Ethash {
 	return &Ethash{
-		turbo:          false,
+		turbo:          true,
 		paramsAndCache: makeParamsAndCache(chainManager, chainManager.CurrentBlock().NumberU64()),
 		chainManager:   chainManager,
 		dag:            nil,
-		ret:            new(C.ethash_return_value),
 		cacheMutex:     new(sync.Mutex),
 		dagMutex:       new(sync.Mutex),
 	}
@@ -142,73 +209,70 @@ func (pow *Ethash) CacheSize() uint64 {
 }
 
 func (pow *Ethash) GetSeedHash(blockNum uint64) []byte {
-	return pow.chainManager.GetBlockByNumber(getSeedBlockNum(blockNum)).Header().Hash()
+	seednum := GetSeedBlockNum(blockNum)
+	return pow.chainManager.GetBlockByNumber(seednum).SeedHash()
 }
 
 func (pow *Ethash) Stop() {
 	pow.cacheMutex.Lock()
 	pow.dagMutex.Lock()
+	defer pow.dagMutex.Unlock()
+	defer pow.cacheMutex.Unlock()
+
 	if pow.paramsAndCache.cache != nil {
 		C.free(pow.paramsAndCache.cache.mem)
 	}
-	if pow.dag != nil {
+	if pow.dag.dag != nil && !pow.dag.file {
 		C.free(pow.dag.dag)
 	}
-	pow.dagMutex.Unlock()
+	pow.dag.dag = nil
-	pow.cacheMutex.Unlock()
 }
 
-func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) ([]byte, []byte, []byte) {
+func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte, []byte) {
-	pow.updateDAG()
+	//pow.UpdateDAG()
 
 	// Not very elegant, multiple mining instances are not supported
-	pow.dagMutex.Lock()
+	//pow.dagMutex.Lock()
-	pow.cacheMutex.Lock()
+	//pow.cacheMutex.Lock()
-	defer pow.cacheMutex.Unlock()
+	//defer pow.cacheMutex.Unlock()
-	defer pow.dagMutex.Unlock()
+	//defer pow.dagMutex.Unlock()
 
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	miningHash := block.HashNoNonce()
 	diff := block.Difficulty()
-	log.Println("difficulty", diff)
+
 	i := int64(0)
+	starti := i
 	start := time.Now().UnixNano()
-	t := time.Now()
 
 	nonce := uint64(r.Int63())
+	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
+	target := new(big.Int).Div(tt256, diff)
 
+	var ret C.ethash_return_value
 	for {
 		select {
 		case <-stop:
 			powlogger.Infoln("Breaking from mining")
 			pow.HashRate = 0
-			pow.dagMutex.Unlock()
+			return 0, nil, nil
-			return nil, nil, nil
 		default:
 			i++
 
-			if time.Since(t) > (1 * time.Second) {
+			elapsed := time.Now().UnixNano() - start
-				elapsed := time.Now().UnixNano() - start
+			hashes := ((float64(1e9) / float64(elapsed)) * float64(i-starti)) / 1000
-				hashes := ((float64(1e9) / float64(elapsed)) * float64(i)) / 1000
+			pow.HashRate = int64(hashes)
-				pow.HashRate = int64(hashes)
+
-				powlogger.Infoln("Hashing @", pow.HashRate, "khash")
+			C.ethash_full(&ret, pow.dag.dag, pow.paramsAndCache.params, cMiningHash, C.uint64_t(nonce))
+			result := ethutil.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32)))
+
+			if result.Cmp(target) <= 0 {
+				mixDigest := C.GoBytes(unsafe.Pointer(&ret.mix_hash[0]), C.int(32))
+
+				return nonce, mixDigest, pow.GetSeedHash(block.NumberU64())
 
-				t = time.Now()
 			}
 
-			cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash))
-			cnonce := C.uint64_t(nonce)
-			log.Printf("seed hash, nonce: %x %x\n", miningHash, nonce)
-			// pow.hash is the output/return of ethash_full
-			C.ethash_full(pow.ret, pow.dag.dag, pow.paramsAndCache.params, cMiningHash, cnonce)
-			res := C.ethash_check_difficulty((*C.uint8_t)(&pow.ret.result[0]), (*C.uint8_t)(unsafe.Pointer(&diff.Bytes()[0])))
-			if res == 1 {
-				mixDigest := C.GoBytes(unsafe.Pointer(&pow.ret.mix_hash[0]), 32)
-				// We don't really nead 32 bytes here
-				buf := make([]byte, 32)
-				binary.PutUvarint(buf, nonce)
-				return buf, mixDigest, pow.GetSeedHash(block.NumberU64())
-			}
 			nonce += 1
 		}
 
@@ -216,43 +280,32 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) ([]byte, []byte
 			time.Sleep(20 * time.Microsecond)
 		}
 	}
+
 }
 
 func (pow *Ethash) Verify(block pow.Block) bool {
 	// Make sure the SeedHash is set correctly
 	if bytes.Compare(block.SeedHash(), pow.GetSeedHash(block.NumberU64())) != 0 {
-		log.Println("Block had wrong SeedHash")
-		log.Println("Expected: ", pow.GetSeedHash(block.NumberU64()))
-		log.Println("Actual: ", block.SeedHash())
 		return false
 	}
 
-	nonceInt, err := parseNonce(block.Nonce())
+	return pow.verify(block.HashNoNonce(), block.MixDigest(), block.Difficulty(), block.NumberU64(), block.Nonce())
-	if err != nil {
-		log.Println("nonce to int err:", err)
-		return false
-	}
-	return pow.verify(block.HashNoNonce(), block.MixDigest(), block.Difficulty(), block.NumberU64(), nonceInt)
 }
 
 func (pow *Ethash) verify(hash []byte, mixDigest []byte, difficulty *big.Int, blockNum uint64, nonce uint64) bool {
+	fmt.Printf("%x\n%d\n%x\n%x\n", hash, nonce, mixDigest, difficulty.Bytes())
 	// First check: make sure header, mixDigest, nonce are correct without hitting the DAG
 	// This is to prevent DOS attacks
-	chash := (*C.uint8_t)(unsafe.Pointer(&hash))
+	chash := (*C.uint8_t)(unsafe.Pointer(&hash[0]))
 	cnonce := C.uint64_t(nonce)
-	cmixDigest := (*C.uint8_t)(unsafe.Pointer(&mixDigest))
+	target := new(big.Int).Div(tt256, difficulty)
-	cdifficulty := (*C.uint8_t)(unsafe.Pointer(&difficulty.Bytes()[0]))
-	if C.ethash_quick_check_difficulty(chash, cnonce, cmixDigest, cdifficulty) != 1 {
-		log.Println("Failed to pass quick check.  Are you sure that the mix digest is correct?")
-		return false
-	}
 
 	var pAc *ParamsAndCache
 	// If its an old block (doesn't use the current cache)
 	// get the cache for it but don't update (so we don't need the mutex)
 	// Otherwise, it's the current block or a future.
 	// If current, updateCache will do nothing.
-	if getSeedBlockNum(blockNum) < pow.paramsAndCache.SeedBlockNum {
+	if GetSeedBlockNum(blockNum) < pow.paramsAndCache.SeedBlockNum {
 		pAc = makeParamsAndCache(pow.chainManager, blockNum)
 	} else {
 		pow.updateCache()
@@ -261,9 +314,12 @@ func (pow *Ethash) verify(hash []byte, mixDigest []byte, difficulty *big.Int, bl
 		pAc = pow.paramsAndCache
 	}
 
-	C.ethash_light(pow.ret, pAc.cache, pAc.params, chash, cnonce)
+	ret := new(C.ethash_return_value)
-	res := C.ethash_check_difficulty((*C.uint8_t)(unsafe.Pointer(&pow.ret.result[0])), cdifficulty)
+
-	return res == 1
+	C.ethash_light(ret, pAc.cache, pAc.params, chash, cnonce)
+
+	result := ethutil.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32)))
+	return result.Cmp(target) <= 0
 }
 
 func (pow *Ethash) GetHashrate() int64 {
@@ -275,22 +331,23 @@ func (pow *Ethash) Turbo(on bool) {
 }
 
 func (pow *Ethash) FullHash(nonce uint64, miningHash []byte) []byte {
-	pow.updateDAG()
+	pow.UpdateDAG()
 	pow.dagMutex.Lock()
 	defer pow.dagMutex.Unlock()
-	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash))
+	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
 	cnonce := C.uint64_t(nonce)
-	log.Println("seed hash, nonce:", miningHash, nonce)
+	ret := new(C.ethash_return_value)
 	// pow.hash is the output/return of ethash_full
-	C.ethash_full(pow.ret, pow.dag.dag, pow.paramsAndCache.params, cMiningHash, cnonce)
+	C.ethash_full(ret, pow.dag.dag, pow.paramsAndCache.params, cMiningHash, cnonce)
-	ghash_full := C.GoBytes(unsafe.Pointer(&pow.ret.result[0]), 32)
+	ghash_full := C.GoBytes(unsafe.Pointer(&ret.result), 32)
 	return ghash_full
 }
 
 func (pow *Ethash) LightHash(nonce uint64, miningHash []byte) []byte {
-	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash))
+	cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0]))
 	cnonce := C.uint64_t(nonce)
-	C.ethash_light(pow.ret, pow.paramsAndCache.cache, pow.paramsAndCache.params, cMiningHash, cnonce)
+	ret := new(C.ethash_return_value)
-	ghash_light := C.GoBytes(unsafe.Pointer(&pow.ret.result[0]), 32)
+	C.ethash_light(ret, pow.paramsAndCache.cache, pow.paramsAndCache.params, cMiningHash, cnonce)
+	ghash_light := C.GoBytes(unsafe.Pointer(&ret.result), 32)
 	return ghash_light
 }

Godeps/_workspace/src/github.com/ethereum/ethash/js/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Tim Hughes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js

@@ -0,0 +1,190 @@
+// ethash.js
+// Tim Hughes <tim@twistedfury.com>
+// Revision 19
+
+/*jslint node: true, shadow:true */
+"use strict";
+
+var Keccak = require('./keccak');
+var util = require('./util');
+
+// 32-bit unsigned modulo
+function mod32(x, n)
+{
+	return (x>>>0) % (n>>>0);
+}
+
+function fnv(x, y)
+{
+	// js integer multiply by 0x01000193 will lose precision
+	return ((x*0x01000000 | 0) + (x*0x193 | 0)) ^ y;	
+}
+
+function computeCache(params, seedWords)
+{
+	var cache = new Uint32Array(params.cacheSize >> 2);
+	var cacheNodeCount = params.cacheSize >> 6;
+
+	// Initialize cache
+	var keccak = new Keccak();
+	keccak.digestWords(cache, 0, 16, seedWords, 0, seedWords.length);
+	for (var n = 1; n < cacheNodeCount; ++n)
+	{
+		keccak.digestWords(cache, n<<4, 16, cache, (n-1)<<4, 16);
+	}
+	
+	var tmp = new Uint32Array(16);
+	
+	// Do randmemohash passes
+	for (var r = 0; r < params.cacheRounds; ++r)
+	{
+		for (var n = 0; n < cacheNodeCount; ++n)
+		{
+			var p0 = mod32(n + cacheNodeCount - 1, cacheNodeCount) << 4;
+			var p1 = mod32(cache[n<<4|0], cacheNodeCount) << 4;
+			
+			for (var w = 0; w < 16; w=(w+1)|0)
+			{
+				tmp[w] = cache[p0 | w] ^ cache[p1 | w];
+			}
+			
+			keccak.digestWords(cache, n<<4, 16, tmp, 0, tmp.length);
+		}
+	}	
+	return cache;
+}
+
+function computeDagNode(o_node, params, cache, keccak, nodeIndex)
+{
+	var cacheNodeCount = params.cacheSize >> 6;
+	var dagParents = params.dagParents;
+	
+	var c = (nodeIndex % cacheNodeCount) << 4;
+	var mix = o_node;
+	for (var w = 0; w < 16; ++w)
+	{
+		mix[w] = cache[c|w];
+	}
+	mix[0] ^= nodeIndex;
+	keccak.digestWords(mix, 0, 16, mix, 0, 16);
+	
+	for (var p = 0; p < dagParents; ++p)
+	{
+		// compute cache node (word) index
+		c = mod32(fnv(nodeIndex ^ p, mix[p&15]), cacheNodeCount) << 4;
+		
+		for (var w = 0; w < 16; ++w)
+		{
+			mix[w] = fnv(mix[w], cache[c|w]);
+		}
+	}
+	
+	keccak.digestWords(mix, 0, 16, mix, 0, 16);
+}
+
+function computeHashInner(mix, params, cache, keccak, tempNode)
+{
+	var mixParents = params.mixParents|0;
+	var mixWordCount = params.mixSize >> 2;
+	var mixNodeCount = mixWordCount >> 4;
+	var dagPageCount = (params.dagSize / params.mixSize) >> 0;
+	
+	// grab initial first word
+	var s0 = mix[0];
+	
+	// initialise mix from initial 64 bytes
+	for (var w = 16; w < mixWordCount; ++w)
+	{
+		mix[w] = mix[w & 15];
+	}
+	
+	for (var a = 0; a < mixParents; ++a)
+	{
+		var p = mod32(fnv(s0 ^ a, mix[a & (mixWordCount-1)]), dagPageCount);
+		var d = (p * mixNodeCount)|0;
+		
+		for (var n = 0, w = 0; n < mixNodeCount; ++n, w += 16)
+		{
+			computeDagNode(tempNode, params, cache, keccak, (d + n)|0);
+			
+			for (var v = 0; v < 16; ++v)
+			{
+				mix[w|v] = fnv(mix[w|v], tempNode[v]);
+			}
+		}
+	}
+}
+
+function convertSeed(seed)
+{
+	// todo, reconcile with spec, byte ordering?
+	// todo, big-endian conversion
+	var newSeed = util.toWords(seed);
+	if (newSeed === null)
+		throw Error("Invalid seed '" + seed + "'");
+	return newSeed;
+}
+
+exports.defaultParams = function()
+{
+	return {
+		cacheSize: 1048384,
+		cacheRounds: 3,
+		dagSize: 1073739904,
+		dagParents: 256,
+		mixSize: 128,
+		mixParents: 64,
+	};
+};
+
+exports.Ethash = function(params, seed)
+{
+	// precompute cache and related values
+	seed = convertSeed(seed);
+	var cache = computeCache(params, seed);
+	
+	// preallocate buffers/etc
+	var initBuf = new ArrayBuffer(96);
+	var initBytes = new Uint8Array(initBuf);
+	var initWords = new Uint32Array(initBuf);
+	var mixWords = new Uint32Array(params.mixSize / 4);
+	var tempNode = new Uint32Array(16);
+	var keccak = new Keccak();
+	
+	var retWords = new Uint32Array(8);
+	var retBytes = new Uint8Array(retWords.buffer); // supposedly read-only
+	
+	this.hash = function(header, nonce)
+	{
+		// compute initial hash
+		initBytes.set(header, 0);
+		initBytes.set(nonce, 32);
+		keccak.digestWords(initWords, 0, 16, initWords, 0, 8 + nonce.length/4);
+		
+		// compute mix
+		for (var i = 0; i != 16; ++i)
+		{
+			mixWords[i] = initWords[i];
+		}
+		computeHashInner(mixWords, params, cache, keccak, tempNode);
+		
+		// compress mix and append to initWords
+		for (var i = 0; i != mixWords.length; i += 4)
+		{
+			initWords[16 + i/4] = fnv(fnv(fnv(mixWords[i], mixWords[i+1]), mixWords[i+2]), mixWords[i+3]);
+		}
+			
+		// final Keccak hashes
+		keccak.digestWords(retWords, 0, 8, initWords, 0, 24); // Keccak-256(s + cmix)
+		return retBytes;
+	};
+	
+	this.cacheDigest = function()
+	{
+		return keccak.digest(32, new Uint8Array(cache.buffer));
+	};
+};
+
+
+
+

Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js

@@ -0,0 +1,404 @@
+// keccak.js
+// Tim Hughes <tim@twistedfury.com>
+// derived from Markku-Juhani O. Saarinen's C code (http://keccak.noekeon.org/readable_code.html)
+
+/*jslint node: true, shadow:true */
+"use strict";
+
+var Keccak_f1600_RC = new Uint32Array([
+	0x00000001, 0x00000000,
+	0x00008082, 0x00000000,
+	0x0000808a, 0x80000000,
+	0x80008000, 0x80000000,
+	0x0000808b, 0x00000000,
+	0x80000001, 0x00000000,
+	0x80008081, 0x80000000,
+	0x00008009, 0x80000000,
+	0x0000008a, 0x00000000,
+	0x00000088, 0x00000000,
+	0x80008009, 0x00000000,
+	0x8000000a, 0x00000000,
+	0x8000808b, 0x00000000,
+	0x0000008b, 0x80000000,
+	0x00008089, 0x80000000,
+	0x00008003, 0x80000000,
+	0x00008002, 0x80000000,
+	0x00000080, 0x80000000,
+	0x0000800a, 0x00000000,
+	0x8000000a, 0x80000000,
+	0x80008081, 0x80000000,
+	0x00008080, 0x80000000,
+	0x80000001, 0x00000000,
+	0x80008008, 0x80000000
+]);
+
+function keccak_f1600(outState, outOffset, outSize, inState)
+{
+	// todo, handle big endian loads
+	var a00l = inState[0]|0;
+	var a00h = inState[1]|0;
+	var a01l = inState[2]|0;
+	var a01h = inState[3]|0;
+	var a02l = inState[4]|0;
+	var a02h = inState[5]|0;
+	var a03l = inState[6]|0;
+	var a03h = inState[7]|0;
+	var a04l = inState[8]|0;
+	var a04h = inState[9]|0;
+	var a05l = inState[10]|0;
+	var a05h = inState[11]|0;
+	var a06l = inState[12]|0;
+	var a06h = inState[13]|0;
+	var a07l = inState[14]|0;
+	var a07h = inState[15]|0;
+	var a08l = inState[16]|0;
+	var a08h = inState[17]|0;
+	var a09l = inState[18]|0;
+	var a09h = inState[19]|0;
+	var a10l = inState[20]|0;
+	var a10h = inState[21]|0;
+	var a11l = inState[22]|0;
+	var a11h = inState[23]|0;
+	var a12l = inState[24]|0;
+	var a12h = inState[25]|0;
+	var a13l = inState[26]|0;
+	var a13h = inState[27]|0;
+	var a14l = inState[28]|0;
+	var a14h = inState[29]|0;
+	var a15l = inState[30]|0;
+	var a15h = inState[31]|0;
+	var a16l = inState[32]|0;
+	var a16h = inState[33]|0;
+	var a17l = inState[34]|0;
+	var a17h = inState[35]|0;
+	var a18l = inState[36]|0;
+	var a18h = inState[37]|0;
+	var a19l = inState[38]|0;
+	var a19h = inState[39]|0;
+	var a20l = inState[40]|0;
+	var a20h = inState[41]|0;
+	var a21l = inState[42]|0;
+	var a21h = inState[43]|0;
+	var a22l = inState[44]|0;
+	var a22h = inState[45]|0;
+	var a23l = inState[46]|0;
+	var a23h = inState[47]|0;
+	var a24l = inState[48]|0;
+	var a24h = inState[49]|0;
+	var b00l, b00h, b01l, b01h, b02l, b02h, b03l, b03h, b04l, b04h;
+	var b05l, b05h, b06l, b06h, b07l, b07h, b08l, b08h, b09l, b09h;
+	var b10l, b10h, b11l, b11h, b12l, b12h, b13l, b13h, b14l, b14h;
+	var b15l, b15h, b16l, b16h, b17l, b17h, b18l, b18h, b19l, b19h;
+	var b20l, b20h, b21l, b21h, b22l, b22h, b23l, b23h, b24l, b24h;
+	var tl, nl;
+	var th, nh;
+
+	for (var r = 0; r < 48; r = (r+2)|0)
+	{
+		// Theta
+		b00l = a00l ^ a05l ^ a10l ^ a15l ^ a20l;
+		b00h = a00h ^ a05h ^ a10h ^ a15h ^ a20h;
+		b01l = a01l ^ a06l ^ a11l ^ a16l ^ a21l;
+		b01h = a01h ^ a06h ^ a11h ^ a16h ^ a21h;
+		b02l = a02l ^ a07l ^ a12l ^ a17l ^ a22l;
+		b02h = a02h ^ a07h ^ a12h ^ a17h ^ a22h;
+		b03l = a03l ^ a08l ^ a13l ^ a18l ^ a23l;
+		b03h = a03h ^ a08h ^ a13h ^ a18h ^ a23h;
+		b04l = a04l ^ a09l ^ a14l ^ a19l ^ a24l;
+		b04h = a04h ^ a09h ^ a14h ^ a19h ^ a24h;
+		tl = b04l ^ (b01l << 1 | b01h >>> 31);
+		th = b04h ^ (b01h << 1 | b01l >>> 31);
+		a00l ^= tl;
+		a00h ^= th;
+		a05l ^= tl;
+		a05h ^= th;
+		a10l ^= tl;
+		a10h ^= th;
+		a15l ^= tl;
+		a15h ^= th;
+		a20l ^= tl;
+		a20h ^= th;
+		tl = b00l ^ (b02l << 1 | b02h >>> 31);
+		th = b00h ^ (b02h << 1 | b02l >>> 31);
+		a01l ^= tl;
+		a01h ^= th;
+		a06l ^= tl;
+		a06h ^= th;
+		a11l ^= tl;
+		a11h ^= th;
+		a16l ^= tl;
+		a16h ^= th;
+		a21l ^= tl;
+		a21h ^= th;
+		tl = b01l ^ (b03l << 1 | b03h >>> 31);
+		th = b01h ^ (b03h << 1 | b03l >>> 31);
+		a02l ^= tl;
+		a02h ^= th;
+		a07l ^= tl;
+		a07h ^= th;
+		a12l ^= tl;
+		a12h ^= th;
+		a17l ^= tl;
+		a17h ^= th;
+		a22l ^= tl;
+		a22h ^= th;
+		tl = b02l ^ (b04l << 1 | b04h >>> 31);
+		th = b02h ^ (b04h << 1 | b04l >>> 31);
+		a03l ^= tl;
+		a03h ^= th;
+		a08l ^= tl;
+		a08h ^= th;
+		a13l ^= tl;
+		a13h ^= th;
+		a18l ^= tl;
+		a18h ^= th;
+		a23l ^= tl;
+		a23h ^= th;
+		tl = b03l ^ (b00l << 1 | b00h >>> 31);
+		th = b03h ^ (b00h << 1 | b00l >>> 31);
+		a04l ^= tl;
+		a04h ^= th;
+		a09l ^= tl;
+		a09h ^= th;
+		a14l ^= tl;
+		a14h ^= th;
+		a19l ^= tl;
+		a19h ^= th;
+		a24l ^= tl;
+		a24h ^= th;
+
+		// Rho Pi
+		b00l = a00l;
+		b00h = a00h;
+		b10l = a01l << 1 | a01h >>> 31;
+		b10h = a01h << 1 | a01l >>> 31;
+		b07l = a10l << 3 | a10h >>> 29;
+		b07h = a10h << 3 | a10l >>> 29;
+		b11l = a07l << 6 | a07h >>> 26;
+		b11h = a07h << 6 | a07l >>> 26;
+		b17l = a11l << 10 | a11h >>> 22;
+		b17h = a11h << 10 | a11l >>> 22;
+		b18l = a17l << 15 | a17h >>> 17;
+		b18h = a17h << 15 | a17l >>> 17;
+		b03l = a18l << 21 | a18h >>> 11;
+		b03h = a18h << 21 | a18l >>> 11;
+		b05l = a03l << 28 | a03h >>> 4;
+		b05h = a03h << 28 | a03l >>> 4;
+		b16l = a05h << 4 | a05l >>> 28;
+		b16h = a05l << 4 | a05h >>> 28;
+		b08l = a16h << 13 | a16l >>> 19;
+		b08h = a16l << 13 | a16h >>> 19;
+		b21l = a08h << 23 | a08l >>> 9;
+		b21h = a08l << 23 | a08h >>> 9;
+		b24l = a21l << 2 | a21h >>> 30;
+		b24h = a21h << 2 | a21l >>> 30;
+		b04l = a24l << 14 | a24h >>> 18;
+		b04h = a24h << 14 | a24l >>> 18;
+		b15l = a04l << 27 | a04h >>> 5;
+		b15h = a04h << 27 | a04l >>> 5;
+		b23l = a15h << 9 | a15l >>> 23;
+		b23h = a15l << 9 | a15h >>> 23;
+		b19l = a23h << 24 | a23l >>> 8;
+		b19h = a23l << 24 | a23h >>> 8;
+		b13l = a19l << 8 | a19h >>> 24;
+		b13h = a19h << 8 | a19l >>> 24;
+		b12l = a13l << 25 | a13h >>> 7;
+		b12h = a13h << 25 | a13l >>> 7;
+		b02l = a12h << 11 | a12l >>> 21;
+		b02h = a12l << 11 | a12h >>> 21;
+		b20l = a02h << 30 | a02l >>> 2;
+		b20h = a02l << 30 | a02h >>> 2;
+		b14l = a20l << 18 | a20h >>> 14;
+		b14h = a20h << 18 | a20l >>> 14;
+		b22l = a14h << 7 | a14l >>> 25;
+		b22h = a14l << 7 | a14h >>> 25;
+		b09l = a22h << 29 | a22l >>> 3;
+		b09h = a22l << 29 | a22h >>> 3;
+		b06l = a09l << 20 | a09h >>> 12;
+		b06h = a09h << 20 | a09l >>> 12;
+		b01l = a06h << 12 | a06l >>> 20;
+		b01h = a06l << 12 | a06h >>> 20;
+
+		// Chi
+		a00l = b00l ^ ~b01l & b02l;
+		a00h = b00h ^ ~b01h & b02h;
+		a01l = b01l ^ ~b02l & b03l;
+		a01h = b01h ^ ~b02h & b03h;
+		a02l = b02l ^ ~b03l & b04l;
+		a02h = b02h ^ ~b03h & b04h;
+		a03l = b03l ^ ~b04l & b00l;
+		a03h = b03h ^ ~b04h & b00h;
+		a04l = b04l ^ ~b00l & b01l;
+		a04h = b04h ^ ~b00h & b01h;
+		a05l = b05l ^ ~b06l & b07l;
+		a05h = b05h ^ ~b06h & b07h;
+		a06l = b06l ^ ~b07l & b08l;
+		a06h = b06h ^ ~b07h & b08h;
+		a07l = b07l ^ ~b08l & b09l;
+		a07h = b07h ^ ~b08h & b09h;
+		a08l = b08l ^ ~b09l & b05l;
+		a08h = b08h ^ ~b09h & b05h;
+		a09l = b09l ^ ~b05l & b06l;
+		a09h = b09h ^ ~b05h & b06h;
+		a10l = b10l ^ ~b11l & b12l;
+		a10h = b10h ^ ~b11h & b12h;
+		a11l = b11l ^ ~b12l & b13l;
+		a11h = b11h ^ ~b12h & b13h;
+		a12l = b12l ^ ~b13l & b14l;
+		a12h = b12h ^ ~b13h & b14h;
+		a13l = b13l ^ ~b14l & b10l;
+		a13h = b13h ^ ~b14h & b10h;
+		a14l = b14l ^ ~b10l & b11l;
+		a14h = b14h ^ ~b10h & b11h;
+		a15l = b15l ^ ~b16l & b17l;
+		a15h = b15h ^ ~b16h & b17h;
+		a16l = b16l ^ ~b17l & b18l;
+		a16h = b16h ^ ~b17h & b18h;
+		a17l = b17l ^ ~b18l & b19l;
+		a17h = b17h ^ ~b18h & b19h;
+		a18l = b18l ^ ~b19l & b15l;
+		a18h = b18h ^ ~b19h & b15h;
+		a19l = b19l ^ ~b15l & b16l;
+		a19h = b19h ^ ~b15h & b16h;
+		a20l = b20l ^ ~b21l & b22l;
+		a20h = b20h ^ ~b21h & b22h;
+		a21l = b21l ^ ~b22l & b23l;
+		a21h = b21h ^ ~b22h & b23h;
+		a22l = b22l ^ ~b23l & b24l;
+		a22h = b22h ^ ~b23h & b24h;
+		a23l = b23l ^ ~b24l & b20l;
+		a23h = b23h ^ ~b24h & b20h;
+		a24l = b24l ^ ~b20l & b21l;
+		a24h = b24h ^ ~b20h & b21h;
+
+		// Iota
+		a00l ^= Keccak_f1600_RC[r|0];
+		a00h ^= Keccak_f1600_RC[r|1];
+	}
+	
+	// todo, handle big-endian stores
+	outState[outOffset|0] = a00l;
+	outState[outOffset|1] = a00h;
+	outState[outOffset|2] = a01l;
+	outState[outOffset|3] = a01h;
+	outState[outOffset|4] = a02l;
+	outState[outOffset|5] = a02h;
+	outState[outOffset|6] = a03l;
+	outState[outOffset|7] = a03h;
+	if (outSize == 8)
+		return;
+	outState[outOffset|8] = a04l;
+	outState[outOffset|9] = a04h;
+	outState[outOffset|10] = a05l;
+	outState[outOffset|11] = a05h;
+	outState[outOffset|12] = a06l;
+	outState[outOffset|13] = a06h;
+	outState[outOffset|14] = a07l;
+	outState[outOffset|15] = a07h;
+	if (outSize == 16)
+		return;
+	outState[outOffset|16] = a08l;
+	outState[outOffset|17] = a08h;
+	outState[outOffset|18] = a09l;
+	outState[outOffset|19] = a09h;
+	outState[outOffset|20] = a10l;
+	outState[outOffset|21] = a10h;
+	outState[outOffset|22] = a11l;
+	outState[outOffset|23] = a11h;
+	outState[outOffset|24] = a12l;
+	outState[outOffset|25] = a12h;
+	outState[outOffset|26] = a13l;
+	outState[outOffset|27] = a13h;
+	outState[outOffset|28] = a14l;
+	outState[outOffset|29] = a14h;
+	outState[outOffset|30] = a15l;
+	outState[outOffset|31] = a15h;
+	outState[outOffset|32] = a16l;
+	outState[outOffset|33] = a16h;
+	outState[outOffset|34] = a17l;
+	outState[outOffset|35] = a17h;
+	outState[outOffset|36] = a18l;
+	outState[outOffset|37] = a18h;
+	outState[outOffset|38] = a19l;
+	outState[outOffset|39] = a19h;
+	outState[outOffset|40] = a20l;
+	outState[outOffset|41] = a20h;
+	outState[outOffset|42] = a21l;
+	outState[outOffset|43] = a21h;
+	outState[outOffset|44] = a22l;
+	outState[outOffset|45] = a22h;
+	outState[outOffset|46] = a23l;
+	outState[outOffset|47] = a23h;
+	outState[outOffset|48] = a24l;
+	outState[outOffset|49] = a24h;
+}
+
+var Keccak = function()
+{
+	var stateBuf = new ArrayBuffer(200);
+	var stateBytes = new Uint8Array(stateBuf);
+	var stateWords = new Uint32Array(stateBuf);
+	
+	this.digest = function(oSize, iBytes)
+	{
+		for (var i = 0; i < 50; ++i)
+		{
+			stateWords[i] = 0;
+		}
+		
+		var r = 200 - oSize*2;
+		var iLength = iBytes.length;
+		var iOffset = 0;	
+		for ( ; ;)
+		{
+			var len = iLength < r ? iLength : r;
+			for (i = 0; i < len; ++i, ++iOffset)
+			{
+				stateBytes[i] ^= iBytes[iOffset];
+			}
+			
+			if (iLength < r)
+				break;
+			iLength -= len;
+			
+			keccak_f1600(stateWords, 0, 50, stateWords);
+		}
+		
+		stateBytes[iLength] ^= 1;
+		stateBytes[r-1] ^= 0x80;
+		keccak_f1600(stateWords, 0, 50, stateWords);
+		return stateBytes.subarray(0, oSize);
+	};
+	
+	this.digestWords = function(oWords, oOffset, oLength, iWords, iOffset, iLength)
+	{
+		for (var i = 0; i < 50; ++i)
+		{
+			stateWords[i] = 0;
+		}
+		
+		var r = 50 - oLength*2;
+		for (; ; )
+		{
+			var len = iLength < r ? iLength : r;
+			for (i = 0; i < len; ++i, ++iOffset)
+			{
+				stateWords[i] ^= iWords[iOffset];
+			}
+			
+			if (iLength < r)
+				break;
+			iLength -= len;
+			
+			keccak_f1600(stateWords, 0, 50, stateWords);
+		}
+		
+		stateBytes[iLength<<2] ^= 1;
+		stateBytes[(r<<2) - 1] ^= 0x80;
+		keccak_f1600(oWords, oOffset, oLength, stateWords);
+	};
+};
+
+module.exports = Keccak;
+
+

Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+// makekeccak.js
+// Tim Hughes <tim@twistedfury.com>
+
+/*jslint node: true, shadow:true */
+"use strict";
+
+var Keccak_f1600_Rho = [
+	1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14, 
+	27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
+];
+
+var Keccak_f1600_Pi= [
+	10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4, 
+	15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1 
+];
+
+var Keccak_f1600_RC = [ 
+	0x00000001, 0x00000000,
+	0x00008082, 0x00000000,
+	0x0000808a, 0x80000000,
+	0x80008000, 0x80000000,
+	0x0000808b, 0x00000000,
+	0x80000001, 0x00000000,
+	0x80008081, 0x80000000,
+	0x00008009, 0x80000000,
+	0x0000008a, 0x00000000,
+	0x00000088, 0x00000000,
+	0x80008009, 0x00000000,
+	0x8000000a, 0x00000000,
+	0x8000808b, 0x00000000,
+	0x0000008b, 0x80000000,
+	0x00008089, 0x80000000,
+	0x00008003, 0x80000000,
+	0x00008002, 0x80000000,
+	0x00000080, 0x80000000,
+	0x0000800a, 0x00000000,
+	0x8000000a, 0x80000000,
+	0x80008081, 0x80000000,
+	0x00008080, 0x80000000,
+	0x80000001, 0x00000000,
+	0x80008008, 0x80000000,
+];
+
+function makeRotLow(lo, hi, n)
+{
+	if (n === 0 || n === 32) throw Error("unsupported");
+	if ((n & 0x20) !== 0)
+	{
+		n &= ~0x20;
+		var t = hi;
+		hi = lo;
+		lo = t;
+	}
+	var hir = hi + " >>> " + (32 - n);
+	var los = lo + " << " + n;
+	return los + " | " + hir;
+}
+
+function makeRotHigh(lo, hi, n)
+{
+	if (n === 0 || n === 32) throw Error("unsupported");
+	if ((n & 0x20) !== 0)
+	{
+		n &= ~0x20;
+		var t = hi;
+		hi = lo;
+		lo = t;
+	}
+	var his = hi + " << " + n;
+	var lor = lo + " >>> " + (32 - n);
+	return his + " | " + lor;
+}
+
+function makeKeccak_f1600()
+{
+	var format = function(n)
+	{
+		return n < 10 ? "0"+n : ""+n;
+	};
+	
+	var a = function(n, w)
+	{
+		return "a" + format(n) + (w !== 0?'h':'l');
+	};
+	
+	var b = function(n, w)
+	{
+		return "b" + format(n) + (w !== 0?'h':'l');
+	};
+	
+	var str = "";	
+	str += "function keccak_f1600(outState, outOffset, outSize, inState)\n";
+	str += "{\n";
+	
+	for (var i = 0; i < 25; ++i)
+	{
+		for (var w = 0; w <= 1; ++w)
+		{
+			str += "\tvar " + a(i,w) + " = inState["+(i<<1|w)+"]|0;\n";
+		}
+	}
+	
+	for (var j = 0; j < 5; ++j)
+	{
+		str += "\tvar ";
+		for (var i = 0; i < 5; ++i)
+		{
+			if (i !== 0)
+				str += ", ";
+			str += b(j*5+i,0) + ", " + b(j*5+i,1);
+		}
+		str += ";\n";
+	}
+	
+	str += "\tvar tl, th;\n";
+	str += "\n";
+	str += "\tfor (var r = 0; r < 48; r = (r+2)|0)\n";
+	str += "\t{\n";
+	
+	
+	// Theta
+	str += "\t\t// Theta\n";
+	for (var i = 0; i < 5; ++i)
+	{
+		for (var w = 0; w <= 1; ++w)
+		{
+			str += "\t\t" + b(i,w) + " = " + a(i,w) + " ^ " + a(i+5,w) + " ^ " + a(i+10,w) + " ^ " + a(i+15,w) + " ^ " + a(i+20,w) + ";\n";
+		}
+	}
+	
+	for (var i = 0; i < 5; ++i)
+	{
+		var i4 = (i + 4) % 5;
+		var i1 = (i + 1) % 5;
+		str += "\t\ttl = " + b(i4,0) + " ^ (" + b(i1,0) + " << 1 | " + b(i1,1) + " >>> 31);\n";
+		str += "\t\tth = " + b(i4,1) + " ^ (" + b(i1,1) + " << 1 | " + b(i1,0) + " >>> 31);\n";
+
+		for (var j = 0; j < 25; j = (j+5)|0)
+		{
+			str += "\t\t" + a((j+i),0) + " ^= tl;\n";
+			str += "\t\t" + a((j+i),1) + " ^= th;\n";
+		}
+	}
+	
+
+	// Rho Pi
+	str += "\n\t\t// Rho Pi\n";
+	for (var w = 0; w <= 1; ++w)
+	{
+		str += "\t\t" + b(0,w) + " = " + a(0,w) + ";\n";
+	}
+	var opi = 1;
+	for (var i = 0; i < 24; ++i)
+	{
+		var pi = Keccak_f1600_Pi[i];
+		str += "\t\t" + b(pi,0) + " = " + makeRotLow(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
+		str += "\t\t" + b(pi,1) + " = " + makeRotHigh(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
+		opi = pi;
+	}
+	
+	//  Chi
+	str += "\n\t\t// Chi\n";
+	for (var j = 0; j < 25; j += 5)
+	{
+		for (var i = 0; i < 5; ++i)
+		{
+			for (var w = 0; w <= 1; ++w)
+			{
+				str += "\t\t" + a(j+i,w) + " = " + b(j+i,w) + " ^ ~" + b(j+(i+1)%5,w) + " & " + b(j+(i+2)%5,w) + ";\n";
+			}
+		}
+	}
+
+	//  Iota
+	str += "\n\t\t// Iota\n";
+	for (var w = 0; w <= 1; ++w)
+	{
+		str += "\t\t" + a(0,w) + " ^= Keccak_f1600_RC[r|" + w + "];\n";
+	}
+	
+	
+	str += "\t}\n";
+	
+	for (var i = 0; i < 25; ++i)
+	{
+		if (i == 4 || i == 8)
+		{
+			str += "\tif (outSize == " + i*2 + ")\n\t\treturn;\n";
+		}
+		for (var w = 0; w <= 1; ++w)
+		{
+			str += "\toutState[outOffset|"+(i<<1|w)+"] = " + a(i,w) + ";\n";
+		}
+	}
+	str += "}\n";
+	
+	return str;
+}
+
+console.log(makeKeccak_f1600());

Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js

@@ -0,0 +1,53 @@
+// test.js
+// Tim Hughes <tim@twistedfury.com>
+
+/*jslint node: true, shadow:true */
+"use strict";
+
+var ethash = require('./ethash');
+var util = require('./util');
+var Keccak = require('./keccak');
+
+// sanity check hash functions
+var src = util.stringToBytes("");
+if (util.bytesToHexString(new Keccak().digest(32, src)) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 failed");
+if (util.bytesToHexString(new Keccak().digest(64, src)) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 failed");
+
+src = new Uint32Array(src.buffer);
+var dst = new Uint32Array(8);
+new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
+if (util.wordsToHexString(dst) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 Fast failed");
+
+var dst = new Uint32Array(16);
+new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
+if (util.wordsToHexString(dst) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 Fast failed");
+
+
+// init params
+var ethashParams = ethash.defaultParams();
+//ethashParams.cacheRounds = 0;
+
+// create hasher
+var seed = util.hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466")
+var startTime = new Date().getTime();
+var hasher = new ethash.Ethash(ethashParams, seed);
+console.log('Ethash startup took: '+(new Date().getTime() - startTime) + "ms");
+console.log('Ethash cache hash: ' + util.bytesToHexString(hasher.cacheDigest()));
+
+var testHexString = "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
+if (testHexString != util.bytesToHexString(util.hexStringToBytes(testHexString)))
+	throw Error("bytesToHexString or hexStringToBytes broken");
+
+		
+var header = util.hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
+var nonce = util.hexStringToBytes("0000000000000000");
+var hash;
+
+startTime = new Date().getTime();
+var trials = 10;
+for (var i = 0; i < trials; ++i)
+{
+	hash = hasher.hash(header, nonce);
+}
+console.log("Light client hashes averaged: " + (new Date().getTime() - startTime)/trials + "ms");
+console.log("Hash = " + util.bytesToHexString(hash));

Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js

@@ -0,0 +1,100 @@
+// util.js
+// Tim Hughes <tim@twistedfury.com>
+
+/*jslint node: true, shadow:true */
+"use strict";
+
+function nibbleToChar(nibble)
+{
+	return String.fromCharCode((nibble < 10 ? 48 : 87) + nibble);
+}
+
+function charToNibble(chr)
+{
+	if (chr >= 48 && chr <= 57)
+	{
+		return chr - 48;
+	}
+	if (chr >= 65 && chr <= 70)
+	{
+		return chr - 65 + 10;
+	}
+	if (chr >= 97 && chr <= 102)
+	{
+		return chr - 97 + 10;
+	}
+	return 0;
+}
+
+function stringToBytes(str)
+{
+	var bytes = new Uint8Array(str.length);
+	for (var i = 0; i != str.length; ++i)
+	{
+		bytes[i] = str.charCodeAt(i);
+	}
+	return bytes;
+}
+
+function hexStringToBytes(str)
+{
+	var bytes = new Uint8Array(str.length>>>1);
+	for (var i = 0; i != bytes.length; ++i)
+	{
+		bytes[i] = charToNibble(str.charCodeAt(i<<1 | 0)) << 4;
+		bytes[i] |= charToNibble(str.charCodeAt(i<<1 | 1));
+	}
+	return bytes;
+}
+
+function bytesToHexString(bytes)
+{
+	var str = "";
+	for (var i = 0; i != bytes.length; ++i)
+	{
+		str += nibbleToChar(bytes[i] >>> 4);
+		str += nibbleToChar(bytes[i] & 0xf);
+	}
+	return str;
+}
+
+function wordsToHexString(words)
+{
+	return bytesToHexString(new Uint8Array(words.buffer));
+}
+
+function uint32ToHexString(num)
+{
+	var buf = new Uint8Array(4);
+	buf[0] = (num >> 24) & 0xff;
+	buf[1] = (num >> 16) & 0xff;
+	buf[2] = (num >> 8) & 0xff;
+	buf[3] = (num >> 0) & 0xff;
+	return bytesToHexString(buf);
+}
+
+function toWords(input)
+{
+	if (input instanceof Uint32Array)
+	{
+		return input;
+	}
+	else if (input instanceof Uint8Array)
+	{
+		var tmp = new Uint8Array((input.length + 3) & ~3);
+		tmp.set(input);
+		return new Uint32Array(tmp.buffer);
+	}
+	else if (typeof input === typeof "")
+	{
+		return toWords(stringToBytes(input));
+	}
+	return null;
+}
+
+exports.stringToBytes = stringToBytes;
+exports.hexStringToBytes = hexStringToBytes;
+exports.bytesToHexString = bytesToHexString;
+exports.wordsToHexString = wordsToHexString;
+exports.uint32ToHexString = uint32ToHexString;
+exports.toWords = toWords;

Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cl/CMakeLists.txt

@@ -1,12 +0,0 @@
-set(LIBRARY ethash-cl)
-set(CMAKE_BUILD_TYPE Release)
-
-if (NOT OPENCL_FOUND)
-	find_package(OpenCL)
-endif()
-if (OPENCL_FOUND)
-	include_directories(${OPENCL_INCLUDE_DIRS})
-	include_directories(..)
-	add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h)
-	TARGET_LINK_LIBRARIES(${LIBRARY} ${OPENCL_LIBRARIES} ethash)
-endif()

Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/CMakeLists.txt

@@ -1,15 +0,0 @@
-find_package(CUDA)
- 
-# Pass options to NVCC
-
- 
-if (CUDA_FOUND)
-set(CUDA_NVCC_FLAGS "   -gencode;arch=compute_30,code=sm_30;
-                        -gencode;arch=compute_20,code=sm_20;
-                        -gencode;arch=compute_11,code=sm_11;
-                        -gencode;arch=compute_12,code=sm_12;
-                        -gencode;arch=compute_13,code=sm_13;")
-cuda_add_executable(
-    ethash-cuda
-    libethash.cu)
-endif()

Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cu

@@ -1,879 +0,0 @@
-/*
-	Copyright 2009 NVIDIA Corporation.  All rights reserved.
-
-	NOTICE TO LICENSEE:   
-
-	This source code and/or documentation ("Licensed Deliverables") are subject 
-	to NVIDIA intellectual property rights under U.S. and international Copyright 
-	laws.  
-
-	These Licensed Deliverables contained herein is PROPRIETARY and CONFIDENTIAL 
-	to NVIDIA and is being provided under the terms and conditions of a form of 
-	NVIDIA software license agreement by and between NVIDIA and Licensee ("License 
-	Agreement") or electronically accepted by Licensee.  Notwithstanding any terms 
-	or conditions to the contrary in the License Agreement, reproduction or 
-	disclosure of the Licensed Deliverables to any third party without the express 
-	written consent of NVIDIA is prohibited.     
-
-	NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, 
-	NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THESE LICENSED 
-	DELIVERABLES FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED 
-	WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE 
-	LICENSED DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, 
-	NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.   NOTWITHSTANDING ANY 
-	TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, IN NO EVENT SHALL 
-	NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, 
-	OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,	WHETHER 
-	IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  ARISING OUT OF 
-	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THESE LICENSED DELIVERABLES.  
-
-	U.S. Government End Users. These Licensed Deliverables are a "commercial item" 
-	as that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of 
-	"commercial computer  software"  and "commercial computer software documentation" 
-	as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995) and is provided to the 
-	U.S. Government only as a commercial end item.  Consistent with 48 C.F.R.12.212 
-	and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all U.S. Government 
-	End Users acquire the Licensed Deliverables with only those rights set forth 
-	herein. 
-
-	Any use of the Licensed Deliverables in individual and commercial software must 
-	include, in the user documentation and internal comments to the code, the above 
-	Disclaimer and U.S. Government End Users Notice.
- */
-
-/*
- *	cuPrintf.cu
- *
- *	This is a printf command callable from within a kernel. It is set
- *	up so that output is sent to a memory buffer, which is emptied from
- *	the host side - but only after a cudaThreadSynchronize() on the host.
- *
- *	Currently, there is a limitation of around 200 characters of output
- *	and no more than 10 arguments to a single cuPrintf() call. Issue
- *	multiple calls if longer format strings are required.
- *
- *	It requires minimal setup, and is *NOT* optimised for performance.
- *	For example, writes are not coalesced - this is because there is an
- *	assumption that people will not want to printf from every single one
- *	of thousands of threads, but only from individual threads at a time.
- *
- *	Using this is simple - it requires one host-side call to initialise
- *	everything, and then kernels can call cuPrintf at will. Sample code
- *	is the easiest way to demonstrate:
- *
-	#include "cuPrintf.cu"
- 	
-	__global__ void testKernel(int val)
-	{
-		cuPrintf("Value is: %d\n", val);
-	}
-
-	int main()
-	{
-		cudaPrintfInit();
-		testKernel<<< 2, 3 >>>(10);
-		cudaPrintfDisplay(stdout, true);
-		cudaPrintfEnd();
-        return 0;
-	}
- *
- *	See the header file, "cuPrintf.cuh" for more info, especially
- *	arguments to cudaPrintfInit() and cudaPrintfDisplay();
- */
-
-#ifndef CUPRINTF_CU
-#define CUPRINTF_CU
-
-#include "cuPrintf.cuh"
-#if __CUDA_ARCH__ > 100      // Atomics only used with > sm_10 architecture
-#include <sm_11_atomic_functions.h>
-#endif
-
-// This is the smallest amount of memory, per-thread, which is allowed.
-// It is also the largest amount of space a single printf() can take up
-const static int CUPRINTF_MAX_LEN = 256;
-
-// This structure is used internally to track block/thread output restrictions.
-typedef struct __align__(8) {
-	int threadid;				// CUPRINTF_UNRESTRICTED for unrestricted
-	int blockid;				// CUPRINTF_UNRESTRICTED for unrestricted
-} cuPrintfRestriction;
-
-// The main storage is in a global print buffer, which has a known
-// start/end/length. These are atomically updated so it works as a
-// circular buffer.
-// Since the only control primitive that can be used is atomicAdd(),
-// we cannot wrap the pointer as such. The actual address must be
-// calculated from printfBufferPtr by mod-ing with printfBufferLength.
-// For sm_10 architecture, we must subdivide the buffer per-thread
-// since we do not even have an atomic primitive.
-__constant__ static char *globalPrintfBuffer = NULL;         // Start of circular buffer (set up by host)
-__constant__ static int printfBufferLength = 0;              // Size of circular buffer (set up by host)
-__device__ static cuPrintfRestriction restrictRules;         // Output restrictions
-__device__ volatile static char *printfBufferPtr = NULL;     // Current atomically-incremented non-wrapped offset
-
-// This is the header preceeding all printf entries.
-// NOTE: It *must* be size-aligned to the maximum entity size (size_t)
-typedef struct __align__(8) {
-    unsigned short magic;                   // Magic number says we're valid
-    unsigned short fmtoffset;               // Offset of fmt string into buffer
-    unsigned short blockid;                 // Block ID of author
-    unsigned short threadid;                // Thread ID of author
-} cuPrintfHeader;
-
-// Special header for sm_10 architecture
-#define CUPRINTF_SM10_MAGIC   0xC810        // Not a valid ascii character
-typedef struct __align__(16) {
-    unsigned short magic;                   // sm_10 specific magic number
-    unsigned short unused;
-    unsigned int thread_index;              // thread ID for this buffer
-    unsigned int thread_buf_len;            // per-thread buffer length
-    unsigned int offset;                    // most recent printf's offset
-} cuPrintfHeaderSM10;
-
-
-// Because we can't write an element which is not aligned to its bit-size,
-// we have to align all sizes and variables on maximum-size boundaries.
-// That means sizeof(double) in this case, but we'll use (long long) for
-// better arch<1.3 support
-#define CUPRINTF_ALIGN_SIZE      sizeof(long long)
-
-// All our headers are prefixed with a magic number so we know they're ready
-#define CUPRINTF_SM11_MAGIC  (unsigned short)0xC811        // Not a valid ascii character
-
-
-//
-//  getNextPrintfBufPtr
-//
-//  Grabs a block of space in the general circular buffer, using an
-//  atomic function to ensure that it's ours. We handle wrapping
-//  around the circular buffer and return a pointer to a place which
-//  can be written to.
-//
-//  Important notes:
-//      1. We always grab CUPRINTF_MAX_LEN bytes
-//      2. Because of 1, we never worry about wrapping around the end
-//      3. Because of 1, printfBufferLength *must* be a factor of CUPRINTF_MAX_LEN
-//
-//  This returns a pointer to the place where we own.
-//
-__device__ static char *getNextPrintfBufPtr()
-{
-    // Initialisation check
-    if(!printfBufferPtr)
-        return NULL;
-
-	// Thread/block restriction check
-	if((restrictRules.blockid != CUPRINTF_UNRESTRICTED) && (restrictRules.blockid != (blockIdx.x + gridDim.x*blockIdx.y)))
-		return NULL;
-	if((restrictRules.threadid != CUPRINTF_UNRESTRICTED) && (restrictRules.threadid != (threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z)))
-		return NULL;
-
-	// Conditional section, dependent on architecture
-#if __CUDA_ARCH__ == 100
-    // For sm_10 architectures, we have no atomic add - this means we must split the
-    // entire available buffer into per-thread blocks. Inefficient, but what can you do.
-    int thread_count = (gridDim.x * gridDim.y) * (blockDim.x * blockDim.y * blockDim.z);
-    int thread_index = threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z +
-                       (blockIdx.x + gridDim.x*blockIdx.y) * (blockDim.x * blockDim.y * blockDim.z);
-    
-    // Find our own block of data and go to it. Make sure the per-thread length
-	// is a precise multiple of CUPRINTF_MAX_LEN, otherwise we risk size and
-	// alignment issues! We must round down, of course.
-    unsigned int thread_buf_len = printfBufferLength / thread_count;
-	thread_buf_len &= ~(CUPRINTF_MAX_LEN-1);
-
-	// We *must* have a thread buffer length able to fit at least two printfs (one header, one real)
-	if(thread_buf_len < (CUPRINTF_MAX_LEN * 2))
-		return NULL;
-
-	// Now address our section of the buffer. The first item is a header.
-    char *myPrintfBuffer = globalPrintfBuffer + (thread_buf_len * thread_index);
-    cuPrintfHeaderSM10 hdr = *(cuPrintfHeaderSM10 *)(void *)myPrintfBuffer;
-    if(hdr.magic != CUPRINTF_SM10_MAGIC)
-    {
-        // If our header is not set up, initialise it
-        hdr.magic = CUPRINTF_SM10_MAGIC;
-        hdr.thread_index = thread_index;
-        hdr.thread_buf_len = thread_buf_len;
-        hdr.offset = 0;         // Note we start at 0! We pre-increment below.
-        *(cuPrintfHeaderSM10 *)(void *)myPrintfBuffer = hdr;       // Write back the header
-
-        // For initial setup purposes, we might need to init thread0's header too
-        // (so that cudaPrintfDisplay() below will work). This is only run once.
-        cuPrintfHeaderSM10 *tophdr = (cuPrintfHeaderSM10 *)(void *)globalPrintfBuffer;
-        tophdr->thread_buf_len = thread_buf_len;
-    }
-
-    // Adjust the offset by the right amount, and wrap it if need be
-    unsigned int offset = hdr.offset + CUPRINTF_MAX_LEN;
-    if(offset >= hdr.thread_buf_len)
-        offset = CUPRINTF_MAX_LEN;
-
-    // Write back the new offset for next time and return a pointer to it
-    ((cuPrintfHeaderSM10 *)(void *)myPrintfBuffer)->offset = offset;
-    return myPrintfBuffer + offset;
-#else
-    // Much easier with an atomic operation!
-    size_t offset = atomicAdd((unsigned int *)&printfBufferPtr, CUPRINTF_MAX_LEN) - (size_t)globalPrintfBuffer;
-    offset %= printfBufferLength;
-    return globalPrintfBuffer + offset;
-#endif
-}
-
-
-//
-//  writePrintfHeader
-//
-//  Inserts the header for containing our UID, fmt position and
-//  block/thread number. We generate it dynamically to avoid
-//	issues arising from requiring pre-initialisation.
-//
-__device__ static void writePrintfHeader(char *ptr, char *fmtptr)
-{
-    if(ptr)
-    {
-        cuPrintfHeader header;
-        header.magic = CUPRINTF_SM11_MAGIC;
-        header.fmtoffset = (unsigned short)(fmtptr - ptr);
-        header.blockid = blockIdx.x + gridDim.x*blockIdx.y;
-        header.threadid = threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z;
-        *(cuPrintfHeader *)(void *)ptr = header;
-    }
-}
-
-
-//
-//  cuPrintfStrncpy
-//
-//  This special strncpy outputs an aligned length value, followed by the
-//  string. It then zero-pads the rest of the string until a 64-aligned
-//  boundary. The length *includes* the padding. A pointer to the byte
-//  just after the \0 is returned.
-//
-//  This function could overflow CUPRINTF_MAX_LEN characters in our buffer.
-//  To avoid it, we must count as we output and truncate where necessary.
-//
-__device__ static char *cuPrintfStrncpy(char *dest, const char *src, int n, char *end)
-{
-    // Initialisation and overflow check
-    if(!dest || !src || (dest >= end))
-        return NULL;
-
-    // Prepare to write the length specifier. We're guaranteed to have
-    // at least "CUPRINTF_ALIGN_SIZE" bytes left because we only write out in
-    // chunks that size, and CUPRINTF_MAX_LEN is aligned with CUPRINTF_ALIGN_SIZE.
-    int *lenptr = (int *)(void *)dest;
-    int len = 0;
-    dest += CUPRINTF_ALIGN_SIZE;
-
-    // Now copy the string
-    while(n--)
-    {
-        if(dest >= end)     // Overflow check
-            break;
-
-        len++;
-        *dest++ = *src;
-        if(*src++ == '\0')
-            break;
-    }
-
-    // Now write out the padding bytes, and we have our length.
-    while((dest < end) && (((long)dest & (CUPRINTF_ALIGN_SIZE-1)) != 0))
-    {
-        len++;
-        *dest++ = 0;
-    }
-    *lenptr = len;
-    return (dest < end) ? dest : NULL;        // Overflow means return NULL
-}
-
-
-//
-//  copyArg
-//
-//  This copies a length specifier and then the argument out to the
-//  data buffer. Templates let the compiler figure all this out at
-//  compile-time, making life much simpler from the programming
-//  point of view. I'm assuimg all (const char *) is a string, and
-//  everything else is the variable it points at. I'd love to see
-//  a better way of doing it, but aside from parsing the format
-//  string I can't think of one.
-//
-//  The length of the data type is inserted at the beginning (so that
-//  the display can distinguish between float and double), and the
-//  pointer to the end of the entry is returned.
-//
-__device__ static char *copyArg(char *ptr, const char *arg, char *end)
-{
-    // Initialisation check
-    if(!ptr || !arg)
-        return NULL;
-
-    // strncpy does all our work. We just terminate.
-    if((ptr = cuPrintfStrncpy(ptr, arg, CUPRINTF_MAX_LEN, end)) != NULL)
-        *ptr = 0;
-
-    return ptr;
-}
-
-template <typename T>
-__device__ static char *copyArg(char *ptr, T &arg, char *end)
-{
-    // Initisalisation and overflow check. Alignment rules mean that
-    // we're at least CUPRINTF_ALIGN_SIZE away from "end", so we only need
-    // to check that one offset.
-    if(!ptr || ((ptr+CUPRINTF_ALIGN_SIZE) >= end))
-        return NULL;
-
-    // Write the length and argument
-    *(int *)(void *)ptr = sizeof(arg);
-    ptr += CUPRINTF_ALIGN_SIZE;
-    *(T *)(void *)ptr = arg;
-    ptr += CUPRINTF_ALIGN_SIZE;
-    *ptr = 0;
-
-    return ptr;
-}
-
-
-//
-//  cuPrintf
-//
-//  Templated printf functions to handle multiple arguments.
-//  Note we return the total amount of data copied, not the number
-//  of characters output. But then again, who ever looks at the
-//  return from printf() anyway?
-//
-//  The format is to grab a block of circular buffer space, the
-//  start of which will hold a header and a pointer to the format
-//  string. We then write in all the arguments, and finally the
-//  format string itself. This is to make it easy to prevent
-//  overflow of our buffer (we support up to 10 arguments, each of
-//  which can be 12 bytes in length - that means that only the
-//  format string (or a %s) can actually overflow; so the overflow
-//  check need only be in the strcpy function.
-//
-//  The header is written at the very last because that's what
-//  makes it look like we're done.
-//
-//  Errors, which are basically lack-of-initialisation, are ignored
-//  in the called functions because NULL pointers are passed around
-//
-
-// All printf variants basically do the same thing, setting up the
-// buffer, writing all arguments, then finalising the header. For
-// clarity, we'll pack the code into some big macros.
-#define CUPRINTF_PREAMBLE \
-    char *start, *end, *bufptr, *fmtstart; \
-    if((start = getNextPrintfBufPtr()) == NULL) return 0; \
-    end = start + CUPRINTF_MAX_LEN; \
-    bufptr = start + sizeof(cuPrintfHeader);
-
-// Posting an argument is easy
-#define CUPRINTF_ARG(argname) \
-	bufptr = copyArg(bufptr, argname, end);
-
-// After args are done, record start-of-fmt and write the fmt and header
-#define CUPRINTF_POSTAMBLE \
-    fmtstart = bufptr; \
-    end = cuPrintfStrncpy(bufptr, fmt, CUPRINTF_MAX_LEN, end); \
-    writePrintfHeader(start, end ? fmtstart : NULL); \
-    return end ? (int)(end - start) : 0;
-
-__device__ int cuPrintf(const char *fmt)
-{
-	CUPRINTF_PREAMBLE;
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1> __device__ int cuPrintf(const char *fmt, T1 arg1)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-	CUPRINTF_ARG(arg6);
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-	CUPRINTF_ARG(arg6);
-	CUPRINTF_ARG(arg7);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
-{
-	CUPRINTF_PREAMBLE;
-
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-	CUPRINTF_ARG(arg6);
-	CUPRINTF_ARG(arg7);
-	CUPRINTF_ARG(arg8);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-	CUPRINTF_ARG(arg6);
-	CUPRINTF_ARG(arg7);
-	CUPRINTF_ARG(arg8);
-	CUPRINTF_ARG(arg9);
-
-	CUPRINTF_POSTAMBLE;
-}
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
-{
-	CUPRINTF_PREAMBLE;
-	    
-	CUPRINTF_ARG(arg1);
-	CUPRINTF_ARG(arg2);
-	CUPRINTF_ARG(arg3);
-	CUPRINTF_ARG(arg4);
-	CUPRINTF_ARG(arg5);
-	CUPRINTF_ARG(arg6);
-	CUPRINTF_ARG(arg7);
-	CUPRINTF_ARG(arg8);
-	CUPRINTF_ARG(arg9);
-	CUPRINTF_ARG(arg10);
-
-	CUPRINTF_POSTAMBLE;
-}
-#undef CUPRINTF_PREAMBLE
-#undef CUPRINTF_ARG
-#undef CUPRINTF_POSTAMBLE
-
-
-//
-//	cuPrintfRestrict
-//
-//	Called to restrict output to a given thread/block.
-//	We store the info in "restrictRules", which is set up at
-//	init time by the host. It's not the cleanest way to do this
-//	because it means restrictions will last between
-//	invocations, but given the output-pointer continuity,
-//	I feel this is reasonable.
-//
-__device__ void cuPrintfRestrict(int threadid, int blockid)
-{
-    int thread_count = blockDim.x * blockDim.y * blockDim.z;
-	if(((threadid < thread_count) && (threadid >= 0)) || (threadid == CUPRINTF_UNRESTRICTED))
-		restrictRules.threadid = threadid;
-
-	int block_count = gridDim.x * gridDim.y;
-	if(((blockid < block_count) && (blockid >= 0)) || (blockid == CUPRINTF_UNRESTRICTED))
-		restrictRules.blockid = blockid;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-// HOST SIDE
-
-#include <stdio.h>
-static FILE *printf_fp;
-
-static char *printfbuf_start=NULL;
-static char *printfbuf_device=NULL;
-static int printfbuf_len=0;
-
-
-//
-//  outputPrintfData
-//
-//  Our own internal function, which takes a pointer to a data buffer
-//  and passes it through libc's printf for output.
-//
-//  We receive the formate string and a pointer to where the data is
-//  held. We then run through and print it out.
-//
-//  Returns 0 on failure, 1 on success
-//
-static int outputPrintfData(char *fmt, char *data)
-{
-    // Format string is prefixed by a length that we don't need
-    fmt += CUPRINTF_ALIGN_SIZE;
-
-    // Now run through it, printing everything we can. We must
-    // run to every % character, extract only that, and use printf
-    // to format it.
-    char *p = strchr(fmt, '%');
-    while(p != NULL)
-    {
-        // Print up to the % character
-        *p = '\0';
-        fputs(fmt, printf_fp);
-        *p = '%';           // Put back the %
-
-        // Now handle the format specifier
-        char *format = p++;         // Points to the '%'
-        p += strcspn(p, "%cdiouxXeEfgGaAnps");
-        if(*p == '\0')              // If no format specifier, print the whole thing
-        {
-            fmt = format;
-            break;
-        }
-
-        // Cut out the format bit and use printf to print it. It's prefixed
-        // by its length.
-        int arglen = *(int *)data;
-        if(arglen > CUPRINTF_MAX_LEN)
-        {
-            fputs("Corrupt printf buffer data - aborting\n", printf_fp);
-            return 0;
-        }
-
-        data += CUPRINTF_ALIGN_SIZE;
-        
-        char specifier = *p++;
-        char c = *p;        // Store for later
-        *p = '\0';
-        switch(specifier)
-        {
-            // These all take integer arguments
-            case 'c':
-            case 'd':
-            case 'i':
-            case 'o':
-            case 'u':
-            case 'x':
-            case 'X':
-            case 'p':
-                fprintf(printf_fp, format, *((int *)data));
-                break;
-
-            // These all take double arguments
-            case 'e':
-            case 'E':
-            case 'f':
-            case 'g':
-            case 'G':
-            case 'a':
-            case 'A':
-                if(arglen == 4)     // Float vs. Double thing
-                    fprintf(printf_fp, format, *((float *)data));
-                else
-                    fprintf(printf_fp, format, *((double *)data));
-                break;
-
-            // Strings are handled in a special way
-            case 's':
-                fprintf(printf_fp, format, (char *)data);
-                break;
-
-            // % is special
-            case '%':
-                fprintf(printf_fp, "%%");
-                break;
-
-            // Everything else is just printed out as-is
-            default:
-                fprintf(printf_fp, format);
-                break;
-        }
-        data += CUPRINTF_ALIGN_SIZE;         // Move on to next argument
-        *p = c;                     // Restore what we removed
-        fmt = p;                    // Adjust fmt string to be past the specifier
-        p = strchr(fmt, '%');       // and get the next specifier
-    }
-
-    // Print out the last of the string
-    fputs(fmt, printf_fp);
-    return 1;
-}
-
-
-//
-//  doPrintfDisplay
-//
-//  This runs through the blocks of CUPRINTF_MAX_LEN-sized data, calling the
-//  print function above to display them. We've got this separate from
-//  cudaPrintfDisplay() below so we can handle the SM_10 architecture
-//  partitioning.
-//
-static int doPrintfDisplay(int headings, int clear, char *bufstart, char *bufend, char *bufptr, char *endptr)
-{
-    // Grab, piece-by-piece, each output element until we catch
-    // up with the circular buffer end pointer
-    int printf_count=0;
-    char printfbuf_local[CUPRINTF_MAX_LEN+1];
-    printfbuf_local[CUPRINTF_MAX_LEN] = '\0';
-
-    while(bufptr != endptr)
-    {
-        // Wrap ourselves at the end-of-buffer
-        if(bufptr == bufend)
-            bufptr = bufstart;
-
-        // Adjust our start pointer to within the circular buffer and copy a block.
-        cudaMemcpy(printfbuf_local, bufptr, CUPRINTF_MAX_LEN, cudaMemcpyDeviceToHost);
-
-        // If the magic number isn't valid, then this write hasn't gone through
-        // yet and we'll wait until it does (or we're past the end for non-async printfs).
-        cuPrintfHeader *hdr = (cuPrintfHeader *)printfbuf_local;
-        if((hdr->magic != CUPRINTF_SM11_MAGIC) || (hdr->fmtoffset >= CUPRINTF_MAX_LEN))
-        {
-            //fprintf(printf_fp, "Bad magic number in printf header\n");
-            break;
-        }
-
-        // Extract all the info and get this printf done
-        if(headings)
-            fprintf(printf_fp, "[%d, %d]: ", hdr->blockid, hdr->threadid);
-        if(hdr->fmtoffset == 0)
-            fprintf(printf_fp, "printf buffer overflow\n");
-        else if(!outputPrintfData(printfbuf_local+hdr->fmtoffset, printfbuf_local+sizeof(cuPrintfHeader)))
-            break;
-        printf_count++;
-
-        // Clear if asked
-        if(clear)
-            cudaMemset(bufptr, 0, CUPRINTF_MAX_LEN);
-
-        // Now advance our start location, because we're done, and keep copying
-        bufptr += CUPRINTF_MAX_LEN;
-    }
-
-    return printf_count;
-}
-
-
-//
-//  cudaPrintfInit
-//
-//  Takes a buffer length to allocate, creates the memory on the device and
-//  returns a pointer to it for when a kernel is called. It's up to the caller
-//  to free it.
-//
-extern "C" cudaError_t cudaPrintfInit(size_t bufferLen)
-{
-    // Fix up bufferlen to be a multiple of CUPRINTF_MAX_LEN
-    bufferLen = (bufferLen < CUPRINTF_MAX_LEN) ? CUPRINTF_MAX_LEN : bufferLen;
-    if((bufferLen % CUPRINTF_MAX_LEN) > 0)
-        bufferLen += (CUPRINTF_MAX_LEN - (bufferLen % CUPRINTF_MAX_LEN));
-    printfbuf_len = (int)bufferLen;
-
-    // Allocate a print buffer on the device and zero it
-    if(cudaMalloc((void **)&printfbuf_device, printfbuf_len) != cudaSuccess)
-		return cudaErrorInitializationError;
-    cudaMemset(printfbuf_device, 0, printfbuf_len);
-    printfbuf_start = printfbuf_device;         // Where we start reading from
-
-	// No restrictions to begin with
-	cuPrintfRestriction restrict;
-	restrict.threadid = restrict.blockid = CUPRINTF_UNRESTRICTED;
-	cudaMemcpyToSymbol(restrictRules, &restrict, sizeof(restrict));
-
-    // Initialise the buffer and the respective lengths/pointers.
-    cudaMemcpyToSymbol(globalPrintfBuffer, &printfbuf_device, sizeof(char *));
-    cudaMemcpyToSymbol(printfBufferPtr, &printfbuf_device, sizeof(char *));
-    cudaMemcpyToSymbol(printfBufferLength, &printfbuf_len, sizeof(printfbuf_len));
-
-    return cudaSuccess;
-}
-
-
-//
-//  cudaPrintfEnd
-//
-//  Frees up the memory which we allocated
-//
-extern "C" void cudaPrintfEnd()
-{
-    if(!printfbuf_start || !printfbuf_device)
-        return;
-
-    cudaFree(printfbuf_device);
-    printfbuf_start = printfbuf_device = NULL;
-}
-
-
-//
-//  cudaPrintfDisplay
-//
-//  Each call to this function dumps the entire current contents
-//	of the printf buffer to the pre-specified FILE pointer. The
-//	circular "start" pointer is advanced so that subsequent calls
-//	dumps only new stuff.
-//
-//  In the case of async memory access (via streams), call this
-//  repeatedly to keep trying to empty the buffer. If it's a sync
-//  access, then the whole buffer should empty in one go.
-//
-//	Arguments:
-//		outputFP     - File descriptor to output to (NULL => stdout)
-//		showThreadID - If true, prints [block,thread] before each line
-//
-extern "C" cudaError_t cudaPrintfDisplay(void *outputFP, bool showThreadID)
-{
-	printf_fp = (FILE *)((outputFP == NULL) ? stdout : outputFP);
-
-    // For now, we force "synchronous" mode which means we're not concurrent
-	// with kernel execution. This also means we don't need clearOnPrint.
-	// If you're patching it for async operation, here's where you want it.
-    bool sync_printfs = true;
-	bool clearOnPrint = false;
-
-    // Initialisation check
-    if(!printfbuf_start || !printfbuf_device || !printf_fp)
-        return cudaErrorMissingConfiguration;
-
-    // To determine which architecture we're using, we read the
-    // first short from the buffer - it'll be the magic number
-    // relating to the version.
-    unsigned short magic;
-    cudaMemcpy(&magic, printfbuf_device, sizeof(unsigned short), cudaMemcpyDeviceToHost);
-
-    // For SM_10 architecture, we've split our buffer into one-per-thread.
-    // That means we must do each thread block separately. It'll require
-    // extra reading. We also, for now, don't support async printfs because
-    // that requires tracking one start pointer per thread.
-    if(magic == CUPRINTF_SM10_MAGIC)
-    {
-        sync_printfs = true;
-	    clearOnPrint = false;
-        int blocklen = 0;
-        char *blockptr = printfbuf_device;
-        while(blockptr < (printfbuf_device + printfbuf_len))
-        {
-            cuPrintfHeaderSM10 hdr;
-            cudaMemcpy(&hdr, blockptr, sizeof(hdr), cudaMemcpyDeviceToHost);
-
-            // We get our block-size-step from the very first header
-            if(hdr.thread_buf_len != 0)
-                blocklen = hdr.thread_buf_len;
-
-            // No magic number means no printfs from this thread
-            if(hdr.magic != CUPRINTF_SM10_MAGIC)
-            {
-                if(blocklen == 0)
-                {
-                    fprintf(printf_fp, "No printf headers found at all!\n");
-                    break;                              // No valid headers!
-                }
-                blockptr += blocklen;
-                continue;
-            }
-
-            // "offset" is non-zero then we can print the block contents
-            if(hdr.offset > 0)
-            {
-                // For synchronous printfs, we must print from endptr->bufend, then from start->end
-                if(sync_printfs)
-                    doPrintfDisplay(showThreadID, clearOnPrint, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len, blockptr+hdr.offset+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len);
-                doPrintfDisplay(showThreadID, clearOnPrint, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.offset+CUPRINTF_MAX_LEN);
-            }
-
-            // Move on to the next block and loop again
-            blockptr += hdr.thread_buf_len;
-        }
-    }
-    // For SM_11 and up, everything is a single buffer and it's simple
-    else if(magic == CUPRINTF_SM11_MAGIC)
-    {
-	    // Grab the current "end of circular buffer" pointer.
-        char *printfbuf_end = NULL;
-        cudaMemcpyFromSymbol(&printfbuf_end, printfBufferPtr, sizeof(char *));
-
-        // Adjust our starting and ending pointers to within the block
-        char *bufptr = ((printfbuf_start - printfbuf_device) % printfbuf_len) + printfbuf_device;
-        char *endptr = ((printfbuf_end - printfbuf_device) % printfbuf_len) + printfbuf_device;
-
-        // For synchronous (i.e. after-kernel-exit) printf display, we have to handle circular
-        // buffer wrap carefully because we could miss those past "end".
-        if(sync_printfs)
-            doPrintfDisplay(showThreadID, clearOnPrint, printfbuf_device, printfbuf_device+printfbuf_len, endptr, printfbuf_device+printfbuf_len);
-        doPrintfDisplay(showThreadID, clearOnPrint, printfbuf_device, printfbuf_device+printfbuf_len, bufptr, endptr);
-
-        printfbuf_start = printfbuf_end;
-    }
-    else
-        ;//printf("Bad magic number in cuPrintf buffer header\n");
-
-    // If we were synchronous, then we must ensure that the memory is cleared on exit
-    // otherwise another kernel launch with a different grid size could conflict.
-    if(sync_printfs)
-        cudaMemset(printfbuf_device, 0, printfbuf_len);
-
-    return cudaSuccess;
-}
-
-// Cleanup
-#undef CUPRINTF_MAX_LEN
-#undef CUPRINTF_ALIGN_SIZE
-#undef CUPRINTF_SM10_MAGIC
-#undef CUPRINTF_SM11_MAGIC
-
-#endif

Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/cuPrintf.cuh

@@ -1,162 +0,0 @@
-/*
-	Copyright 2009 NVIDIA Corporation.  All rights reserved.
-
-	NOTICE TO LICENSEE:   
-
-	This source code and/or documentation ("Licensed Deliverables") are subject 
-	to NVIDIA intellectual property rights under U.S. and international Copyright 
-	laws.  
-
-	These Licensed Deliverables contained herein is PROPRIETARY and CONFIDENTIAL 
-	to NVIDIA and is being provided under the terms and conditions of a form of 
-	NVIDIA software license agreement by and between NVIDIA and Licensee ("License 
-	Agreement") or electronically accepted by Licensee.  Notwithstanding any terms 
-	or conditions to the contrary in the License Agreement, reproduction or 
-	disclosure of the Licensed Deliverables to any third party without the express 
-	written consent of NVIDIA is prohibited.     
-
-	NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, 
-	NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THESE LICENSED 
-	DELIVERABLES FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED 
-	WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE 
-	LICENSED DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, 
-	NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.   NOTWITHSTANDING ANY 
-	TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, IN NO EVENT SHALL 
-	NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, 
-	OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,	WHETHER 
-	IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,  ARISING OUT OF 
-	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THESE LICENSED DELIVERABLES.  
-
-	U.S. Government End Users. These Licensed Deliverables are a "commercial item" 
-	as that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of 
-	"commercial computer  software"  and "commercial computer software documentation" 
-	as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995) and is provided to the 
-	U.S. Government only as a commercial end item.  Consistent with 48 C.F.R.12.212 
-	and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all U.S. Government 
-	End Users acquire the Licensed Deliverables with only those rights set forth 
-	herein. 
-
-	Any use of the Licensed Deliverables in individual and commercial software must 
-	include, in the user documentation and internal comments to the code, the above 
-	Disclaimer and U.S. Government End Users Notice.
- */
-
-#ifndef CUPRINTF_H
-#define CUPRINTF_H
-
-/*
- *	This is the header file supporting cuPrintf.cu and defining both
- *	the host and device-side interfaces. See that file for some more
- *	explanation and sample use code. See also below for details of the
- *	host-side interfaces.
- *
- *  Quick sample code:
- *
-	#include "cuPrintf.cu"
- 	
-	__global__ void testKernel(int val)
-	{
-		cuPrintf("Value is: %d\n", val);
-	}
-
-	int main()
-	{
-		cudaPrintfInit();
-		testKernel<<< 2, 3 >>>(10);
-		cudaPrintfDisplay(stdout, true);
-		cudaPrintfEnd();
-        return 0;
-	}
- */
-
-///////////////////////////////////////////////////////////////////////////////
-// DEVICE SIDE
-// External function definitions for device-side code
-
-// Abuse of templates to simulate varargs
-__device__ int cuPrintf(const char *fmt);
-template <typename T1> __device__ int cuPrintf(const char *fmt, T1 arg1);
-template <typename T1, typename T2> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2);
-template <typename T1, typename T2, typename T3> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3);
-template <typename T1, typename T2, typename T3, typename T4> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4);
-template <typename T1, typename T2, typename T3, typename T4, typename T5> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
-template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
-
-
-//
-//	cuPrintfRestrict
-//
-//	Called to restrict output to a given thread/block. Pass
-//	the constant CUPRINTF_UNRESTRICTED to unrestrict output
-//	for thread/block IDs. Note you can therefore allow
-//	"all printfs from block 3" or "printfs from thread 2
-//	on all blocks", or "printfs only from block 1, thread 5".
-//
-//	Arguments:
-//		threadid - Thread ID to allow printfs from
-//		blockid - Block ID to allow printfs from
-//
-//	NOTE: Restrictions last between invocations of
-//	kernels unless cudaPrintfInit() is called again.
-//
-#define CUPRINTF_UNRESTRICTED	-1
-__device__ void cuPrintfRestrict(int threadid, int blockid);
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-// HOST SIDE
-// External function definitions for host-side code
-
-//
-//	cudaPrintfInit
-//
-//	Call this once to initialise the printf system. If the output
-//	file or buffer size needs to be changed, call cudaPrintfEnd()
-//	before re-calling cudaPrintfInit().
-//
-//	The default size for the buffer is 1 megabyte. For CUDA
-//	architecture 1.1 and above, the buffer is filled linearly and
-//	is completely used;	however for architecture 1.0, the buffer
-//	is divided into as many segments are there are threads, even
-//	if some threads do not call cuPrintf().
-//
-//	Arguments:
-//		bufferLen - Length, in bytes, of total space to reserve
-//		            (in device global memory) for output.
-//
-//	Returns:
-//		cudaSuccess if all is well.
-//
-extern "C" cudaError_t cudaPrintfInit(size_t bufferLen=1048576);   // 1-meg - that's enough for 4096 printfs by all threads put together
-
-//
-//	cudaPrintfEnd
-//
-//	Cleans up all memories allocated by cudaPrintfInit().
-//	Call this at exit, or before calling cudaPrintfInit() again.
-//
-extern "C" void cudaPrintfEnd();
-
-//
-//	cudaPrintfDisplay
-//
-//	Dumps the contents of the output buffer to the specified
-//	file pointer. If the output pointer is not specified,
-//	the default "stdout" is used.
-//
-//	Arguments:
-//		outputFP     - A file pointer to an output stream.
-//		showThreadID - If "true", output strings are prefixed
-//		               by "[blockid, threadid] " at output.
-//
-//	Returns:
-//		cudaSuccess if all is well.
-//
-extern "C" cudaError_t cudaPrintfDisplay(void *outputFP=NULL, bool showThreadID=false);
-
-#endif  // CUPRINTF_H

Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/libethash.cu

@@ -1,27 +0,0 @@
-#include "cuPrintf.cu"
-#include <stdio.h>
-
-__global__ void device_greetings(void)
-{
-	cuPrintf("Hello, world from the device!\n");
-}
-
-int main(void)
-{
-	// greet from the host
-	printf("Hello, world from the host!\n");
-
-	// initialize cuPrintf
-	cudaPrintfInit();
-
-	// launch a kernel with a single thread to greet from the device
-	device_greetings<<<1,1>>>();
-
-	// display the device's greeting
-	cudaPrintfDisplay();
-
-	// clean up after cuPrintf
-	cudaPrintfEnd();
-
-	return 0;
-}

Godeps/_workspace/src/github.com/ethereum/ethash/libethash/data_sizes.h

@@ -1,248 +0,0 @@
-/*
-  This file is part of cpp-ethereum.
-
-  cpp-ethereum is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software FoundationUUU,either version 3 of the LicenseUUU,or
-  (at your option) any later version.
-
-  cpp-ethereum is distributed in the hope that it will be usefulU,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with cpp-ethereum.  If notUUU,see <http://www.gnu.org/licenses/>.
-*/
-
-/** @file nth_prime.h
-* @author Matthew Wampler-Doty <negacthulhu@gmail.com>
-* @date 2015
-*/
-
-// TODO: Update this after ~7 years
-
-#pragma once
-
-#include <stdint.h>
-//#include <Security/Security.h>
-#include "compiler.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdint.h>
-
-// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
-
-// Generated with the following Mathematica Code:
-// GetDataSizes[n_] := Module[{
-//        DAGSizeBytesInit = 2^30,
-//        MixBytes = 128,
-//        DAGGrowth = 113000000,
-//        j = 0},
-//        Reap[
-//          While[j < n,
-//            Module[{i =
-//              Floor[(DAGSizeBytesInit + DAGGrowth * j) / MixBytes]},
-//              While[! PrimeQ[i], i--];
-//              Sow[i*MixBytes]; j++]]]][[2]][[1]]
-
-static const size_t dag_sizes[] = {
-        1073739904U, 1186739584U, 1299741568U, 1412741248U, 1525741696U,
-        1638736768U, 1751741312U, 1864740736U, 1977740672U, 2090740864U,
-        2203740544U, 2316741248U, 2429739392U, 2542740352U, 2655741824U,
-        2768739712U, 2881740416U, 2994741632U, 3107740544U, 3220741504U,
-        3333738112U, 3446741632U, 3559741312U, 3672740224U, 3785740928U,
-        3898738304U, 4011741824U, 4124739712U, 4237735808U, 4350740864U,
-        4463741824U, 4576741504U, 4689741184U, 4802739328U, 4915741568U,
-        5028740224U, 5141740672U, 5254738304U, 5367741824U, 5480737664U,
-        5593738112U, 5706741632U, 5819740544U, 5932734592U, 6045739904U,
-        6158740096U, 6271740032U, 6384731776U, 6497732992U, 6610740352U,
-        6723741056U, 6836741504U, 6949740416U, 7062740096U, 7175741824U,
-        7288740224U, 7401741184U, 7514741632U, 7627741568U, 7740739712U,
-        7853739136U, 7966740352U, 8079741568U, 8192739712U, 8305738624U,
-        8418740864U, 8531740288U, 8644740736U, 8757735808U, 8870738816U,
-        8983739264U, 9096740992U, 9209740928U, 9322739584U, 9435741824U,
-        9548741504U, 9661739392U, 9774738304U, 9887741312U, 10000738688U,
-        10113739136U, 10226741632U, 10339739776U, 10452741248U, 10565740928U,
-        10678736512U, 10791734656U, 10904741248U, 11017738112U, 11130741632U,
-        11243741312U, 11356739456U, 11469740416U, 11582734976U, 11695739008U,
-        11808741248U, 11921734784U, 12034739072U, 12147741568U, 12260737408U,
-        12373741696U, 12486738304U, 12599740544U, 12712740224U, 12825741184U,
-        12938736256U, 13051741312U, 13164737408U, 13277738368U, 13390738048U,
-        13503741824U, 13616741504U, 13729737088U, 13842740096U, 13955741312U,
-        14068741504U, 14181740416U, 14294741632U, 14407739776U, 14520740224U,
-        14633740928U, 14746736512U, 14859741824U, 14972740736U, 15085740928U,
-        15198738304U, 15311732096U, 15424740736U, 15537739904U, 15650741632U,
-        15763741568U, 15876737152U, 15989741696U, 16102740608U, 16215741056U,
-        16328741248U, 16441740416U, 16554737792U, 16667740288U, 16780740992U,
-        16893738112U, 17006741632U, 17119739008U, 17232735616U, 17345739392U,
-        17458740352U, 17571736192U, 17684739712U, 17797739392U, 17910740096U,
-        18023741312U, 18136740736U, 18249738112U, 18362738816U, 18475735424U,
-        18588740224U, 18701738368U, 18814736768U, 18927737216U, 19040739968U,
-        19153739648U, 19266736768U, 19379737984U, 19492739456U, 19605738368U,
-        19718740352U, 19831741312U, 19944736384U, 20057741696U, 20170741376U,
-        20283741824U, 20396737408U, 20509741696U, 20622741376U, 20735739008U,
-        20848741504U, 20961740672U, 21074739328U, 21187740032U, 21300739456U,
-        21413741696U, 21526740608U, 21639741824U, 21752737408U, 21865741696U,
-        21978741376U, 22091741824U, 22204738432U, 22317740672U, 22430740096U,
-        22543736704U, 22656741248U, 22769739904U, 22882739584U, 22995740288U,
-        23108740736U, 23221740928U, 23334741376U, 23447737216U, 23560740992U,
-        23673741184U, 23786740864U, 23899737728U, 24012741248U, 24125734784U,
-        24238736512U, 24351741824U, 24464740736U, 24577737088U, 24690741632U,
-        24803739776U, 24916740736U, 25029740416U, 25142740864U, 25255741568U,
-        25368741248U, 25481740672U, 25594741376U, 25707741568U, 25820741504U,
-        25933730432U, 26046739072U, 26159741824U, 26272741504U, 26385740672U,
-        26498740096U, 26611741568U, 26724740992U, 26837739904U, 26950735232U,
-        27063738496U, 27176741248U, 27289741184U, 27402740864U, 27515740544U,
-        27628737152U, 27741740672U, 27854741632U, 27967740544U, 28080739712U,
-        28193738368U, 28306741376U, 28419737728U, 28532739968U, 28645739648U,
-        28758740096U, 28871741312U, 28984739456U, 29097740416U, 29210740864U,
-        29323741312U, 29436740224U, 29549741696U, 29662738304U, 29775741568U,
-        29888741504U, 30001740928U, 30114737024U, 30227735168U, 30340737664U,
-        30453738368U, 30566737024U, 30679733632U, 30792740224U, 30905740928U,
-        31018740352U, 31131740032U, 31244738944U, 31357737344U, 31470741376U,
-        31583740544U, 31696740224U, 31809738112U, 31922739328U, 32035737472U,
-        32148740992U, 32261741696U, 32374740352U, 32487741824U, 32600740736U,
-        32713739648U, 32826740608U, 32939729792U, 33052740992U, 33165740672U,
-        33278739584U, 33391741312U, 33504739712U, 33617740928U, 33730740608U,
-        33843738496U, 33956739968U, 34069741696U, 34182739328U, 34295741824U,
-        34408739968U, 34521740672U, 34634736512U, 34747741568U, 34860741248U,
-        34973739392U, 35086738304U, 35199741056U, 35312736896U, 35425741184U,
-        35538741376U, 35651740288U, 35764737152U, 35877741184U, 35990739584U,
-        36103740544U, 36216740992U, 36329739392U, 36442737536U, 36555741568U,
-        36668740736U, 36781741184U, 36894737024U, 37007741312U, 37120739456U,
-        37233741184U, 37346736256U, 37459736192U, 37572734336U, 37685739904U,
-        37798740352U, 37911737728U, 38024741504U, 38137739648U, 38250740608U,
-        38363741824U, 38476740992U, 38589741184U, 38702740096U, 38815741312U,
-        38928741248U, 39041738368U, 39154739584U, 39267741824U, 39380739712U,
-        39493735808U, 39606741632U, 39719741312U, 39832741504U, 39945739648U,
-        40058740352U, 40171740032U, 40284740992U, 40397740672U, 40510740352U,
-        40623740288U, 40736738176U, 40849737856U, 40962741376U, 41075739776U,
-        41188737664U, 41301735808U, 41414738048U, 41527741312U, 41640740992U,
-        41753739904U, 41866739072U, 41979738496U, 42092740736U, 42205739648U,
-        42318740608U, 42431741312U, 42544738688U, 42657741184U, 42770738048U,
-        42883741568U, 42996741248U, 43109740928U, 43222736512U, 43335741056U,
-        43448730496U, 43561740416U, 43674741632U, 43787740544U, 43900741504U,
-        44013739648U, 44126740864U, 44239740544U, 44352741248U, 44465738368U,
-        44578735232U, 44691739264U, 44804741504U, 44917741696U, 45030741376U,
-        45143741824U, 45256740992U, 45369739136U, 45482740096U, 45595739776U,
-        45708739712U, 45821740672U, 45934741376U, 46047741056U, 46160741248U,
-        46273737088U, 46386740864U, 46499739008U, 46612739968U, 46725735296U,
-        46838740864U, 46951741568U, 47064737152U, 47177741696U, 47290741376U,
-        47403738752U, 47516741248U, 47629739648U, 47742741632U, 47855737984U,
-        47968740224U, 48081738368U, 48194741632U, 48307739264U, 48420739712U,
-        48533739136U, 48646738304U, 48759741824U, 48872741504U, 48985739392U,
-        49098741376U, 49211741056U, 49324740992U, 49437738368U, 49550740864U,
-        49663735424U, 49776737408U, 49889740672U, 50002738816U, 50115738752U,
-        50228739712U, 50341741696U, 50454736768U, 50567738752U, 50680739968U,
-        50793736832U, 50906734976U, 51019741568U, 51132739456U, 51245741696U,
-        51358741376U, 51471741056U, 51584738944U, 51697734272U, 51810739072U,
-        51923736448U, 52036740736U, 52149741184U, 52262737024U, 52375738496U,
-        52488740992U, 52601739136U, 52714740352U, 52827736448U, 52940738176U,
-        53053741696U, 53166740864U, 53279741824U, 53392741504U, 53505739136U,
-        53618739584U, 53731741312U, 53844741248U, 53957741696U, 54070741376U,
-        54183740288U, 54296741504U, 54409741696U, 54522739072U, 54635737472U,
-        54748741504U, 54861736064U, 54974740096U, 55087741568U, 55200733568U,
-        55313741696U, 55426734464U, 55539741056U, 55652741504U, 55765741184U,
-        55878741376U, 55991730304U, 56104740992U, 56217740672U, 56330731648U,
-        56443737472U, 56556724352U, 56669740672U, 56782739072U, 56895740032U,
-        57008741248U, 57121741696U, 57234740096U, 57347741312U, 57460741504U
-};
-
-// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
-
-// Generated with the following Mathematica Code:
-// GetCacheSizes[n_] := Module[{
-//        DAGSizeBytesInit = 2^30,
-//        MixBytes = 128,
-//        DAGGrowth = 113000000,
-//        HashBytes = 64,
-//        DAGParents = 1024,
-//        j = 0},
-//    Reap[
-//      While[j < n,
-//       Module[{i = Floor[(DAGSizeBytesInit + DAGGrowth * j) / (DAGParents * HashBytes)]},
-//        While[! PrimeQ[i], i--];
-//        Sow[i*HashBytes]; j++]]]][[2]][[1]]
-
-const size_t cache_sizes[] = {
-        1048384U, 1158208U, 1268416U, 1377856U, 1489856U, 1599296U, 1710656U,
-        1820608U, 1930816U, 2041024U, 2151872U, 2261696U, 2371904U, 2482624U,
-        2593216U, 2703296U, 2814016U, 2924224U, 3034816U, 3144896U, 3255488U,
-        3365312U, 3475904U, 3586624U, 3696064U, 3806272U, 3917504U, 4027456U,
-        4138304U, 4248512U, 4359104U, 4469312U, 4579264U, 4689728U, 4797376U,
-        4909888U, 5020096U, 5131328U, 5241664U, 5351744U, 5461312U, 5572544U,
-        5683264U, 5793472U, 5903552U, 6014144U, 6121664U, 6235072U, 6344896U,
-        6454592U, 6565952U, 6675904U, 6786112U, 6896704U, 7006784U, 7117888U,
-        7228096U, 7338304U, 7448768U, 7557952U, 7669184U, 7779776U, 7889216U,
-        8000192U, 8110912U, 8220736U, 8331712U, 8441536U, 8552384U, 8662592U,
-        8772928U, 8883136U, 8993728U, 9103168U, 9214528U, 9323968U, 9434816U,
-        9545152U, 9655616U, 9766336U, 9876544U, 9986624U, 10097344U, 10207424U,
-        10316864U, 10427968U, 10538432U, 10649152U, 10758976U, 10869568U, 10979776U,
-        11089472U, 11200832U, 11309632U, 11420608U, 11531584U, 11641792U, 11751104U,
-        11862976U, 11973184U, 12083264U, 12193856U, 12304064U, 12414656U, 12524608U,
-        12635072U, 12745792U, 12855616U, 12965824U, 13076416U, 13187008U, 13297216U,
-        13407808U, 13518016U, 13627072U, 13738688U, 13848256U, 13959488U, 14069696U,
-        14180288U, 14290624U, 14399552U, 14511424U, 14621504U, 14732096U, 14841664U,
-        14951744U, 15062336U, 15172672U, 15283264U, 15393088U, 15504448U, 15614272U,
-        15723712U, 15834944U, 15945152U, 16055744U, 16165696U, 16277056U, 16387136U,
-        16494784U, 16607936U, 16718272U, 16828736U, 16938176U, 17048384U, 17159872U,
-        17266624U, 17380544U, 17490496U, 17600192U, 17711296U, 17821376U, 17931968U,
-        18041152U, 18152896U, 18261952U, 18373568U, 18483392U, 18594112U, 18703936U,
-        18814912U, 18924992U, 19034944U, 19145408U, 19256128U, 19366208U, 19477184U,
-        19587136U, 19696576U, 19808192U, 19916992U, 20028352U, 20137664U, 20249024U,
-        20358848U, 20470336U, 20580544U, 20689472U, 20801344U, 20911424U, 21020096U,
-        21130688U, 21242176U, 21352384U, 21462208U, 21573824U, 21683392U, 21794624U,
-        21904448U, 22013632U, 22125248U, 22235968U, 22344512U, 22456768U, 22566848U,
-        22677056U, 22786496U, 22897984U, 23008064U, 23118272U, 23228992U, 23338816U,
-        23449408U, 23560256U, 23670464U, 23780672U, 23891264U, 24001216U, 24110656U,
-        24221888U, 24332608U, 24442688U, 24552512U, 24662464U, 24773696U, 24884032U,
-        24994496U, 25105216U, 25215296U, 25324864U, 25435712U, 25546432U, 25655744U,
-        25767232U, 25876672U, 25986368U, 26098112U, 26207936U, 26318912U, 26428736U,
-        26539712U, 26650048U, 26760256U, 26869184U, 26979776U, 27091136U, 27201728U,
-        27311552U, 27422272U, 27532352U, 27642304U, 27752896U, 27863744U, 27973952U,
-        28082752U, 28194752U, 28305344U, 28415168U, 28524992U, 28636352U, 28746304U,
-        28857152U, 28967104U, 29077184U, 29187904U, 29298496U, 29408576U, 29518912U,
-        29628992U, 29739968U, 29850176U, 29960512U, 30070336U, 30180544U, 30290752U,
-        30398912U, 30512192U, 30622784U, 30732992U, 30842176U, 30953536U, 31063744U,
-        31174336U, 31284544U, 31395136U, 31504448U, 31615552U, 31725632U, 31835072U,
-        31946176U, 32057024U, 32167232U, 32277568U, 32387008U, 32497984U, 32608832U,
-        32719168U, 32829376U, 32939584U, 33050048U, 33160768U, 33271232U, 33381184U,
-        33491648U, 33601856U, 33712576U, 33822016U, 33932992U, 34042816U, 34153024U,
-        34263104U, 34373824U, 34485056U, 34594624U, 34704832U, 34816064U, 34926272U,
-        35036224U, 35146816U, 35255104U, 35367104U, 35478208U, 35588416U, 35698496U,
-        35808832U, 35918656U, 36029888U, 36139456U, 36250688U, 36360512U, 36471104U,
-        36581696U, 36691136U, 36802112U, 36912448U, 37022912U, 37132864U, 37242944U,
-        37354048U, 37464512U, 37574848U, 37684928U, 37794752U, 37904704U, 38015552U,
-        38125888U, 38236864U, 38345792U, 38457152U, 38567744U, 38678336U, 38787776U,
-        38897216U, 39009088U, 39117632U, 39230144U, 39340352U, 39450304U, 39560384U,
-        39671488U, 39781312U, 39891392U, 40002112U, 40112704U, 40223168U, 40332608U,
-        40443968U, 40553792U, 40664768U, 40774208U, 40884416U, 40993984U, 41105984U,
-        41215424U, 41326528U, 41436992U, 41546048U, 41655872U, 41768128U, 41878336U,
-        41988928U, 42098752U, 42209344U, 42319168U, 42429248U, 42540352U, 42649792U,
-        42761024U, 42871616U, 42981824U, 43092032U, 43201856U, 43312832U, 43423552U,
-        43533632U, 43643584U, 43753792U, 43864384U, 43974976U, 44084032U, 44195392U,
-        44306368U, 44415296U, 44526016U, 44637248U, 44746816U, 44858048U, 44967872U,
-        45078848U, 45188288U, 45299264U, 45409216U, 45518272U, 45630272U, 45740224U,
-        45850432U, 45960896U, 46069696U, 46182208U, 46292416U, 46402624U, 46512064U,
-        46623296U, 46733888U, 46843712U, 46953664U, 47065024U, 47175104U, 47285696U,
-        47395904U, 47506496U, 47615296U, 47726912U, 47837632U, 47947712U, 48055232U,
-        48168128U, 48277952U, 48387392U, 48499648U, 48609472U, 48720064U, 48830272U,
-        48940096U, 49050944U, 49160896U, 49271744U, 49381568U, 49492288U, 49602752U,
-        49712576U, 49822016U, 49934272U, 50042816U, 50154304U, 50264128U, 50374336U,
-        50484416U, 50596288U, 50706752U, 50816704U, 50927168U, 51035456U, 51146944U,
-        51258176U, 51366976U, 51477824U, 51589568U, 51699776U, 51809728U, 51920576U,
-        52030016U, 52140736U, 52251328U, 52361152U, 52470592U, 52582592U, 52691776U,
-        52803136U, 52912576U, 53020736U, 53132224U, 53242688U, 53354816U, 53465536U,
-        53575232U, 53685568U, 53796544U, 53906752U, 54016832U, 54126656U, 54236992U,
-        54347456U, 54457408U, 54569024U, 54679232U, 54789184U, 54899776U, 55008832U,
-        55119296U, 55231168U, 55341248U, 55451584U, 55562048U, 55672256U, 55782208U,
-        55893184U, 56002112U, 56113216U
-};
-
-#ifdef __cplusplus
-}
-#endif

Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/binding.gyp

@@ -1,29 +0,0 @@
-{
-  "targets":
-    [{
-      "target_name": "ethash",
-        "sources": [
-            './ethash.cc',
-            '../libethash/ethash.h',
-            '../libethash/util.c',
-            '../libethash/util.h',
-            '../libethash/blum_blum_shub.h',
-            '../libethash/blum_blum_shub.c',
-            '../libethash/sha3.h',
-            '../libethash/sha3.c',
-            '../libethash/internal.h',
-            '../libethash/internal.c'
-          ],
-        "include_dirs": [
-          "../",
-          "<!(node -e \"require('nan')\")"
-        ],
-        "cflags": [
-        "-Wall",
-        "-Wno-maybe-uninitialized",
-        "-Wno-uninitialized",
-        "-Wno-unused-function",
-        "-Wextra"
-          ]
-    }]
-}

Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/ethash.cc

@@ -1,587 +0,0 @@
-#include <nan.h>
-#include <iostream>
-#include <node.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include "../libethash/ethash.h"
-
-using namespace v8;
-
-class EthashValidator : public NanAsyncWorker {
- public:
-  // Constructor
-  EthashValidator(NanCallback *callback, const unsigned blocknumber, const unsigned char * seed)
-    : NanAsyncWorker(callback), blocknumber(blocknumber), seed(seed) {}
-  // Destructor
-  ~EthashValidator() {
-  	free(this->cache);
-	free(this->params);
-  }
-
-  // Executed inside the worker-thread.
-  // It is not safe to access V8, or V8 data structures
-  // here, so everything we need for input and output
-  // should go on `this`.
-  void Execute () {
-	
-    /* this->result = secp256k1_ecdsa_sign(this->msg, this->sig , &this->sig_len, this->pk, NULL, NULL); */
-  }
-
-  // Executed when the async work is complete
-  // this function will be run inside the main event loop
-  // so it is safe to use V8 again
-  void HandleOKCallback () {
-    NanScope();
-    Handle<Value> argv[] = {
-      NanNew<Number>(this->result)
-    };
-    callback->Call(2, argv);
-  }
-
- protected:
-  const unsigned blocknumber; 
-  const unsigned char * seed;
-  ethash_params * params;
-  ethash_cache * cache;
-  bool result;
-  bool ready = 0;
-};
-
-/* class CompactSignWorker : public SignWorker { */
-/*  public: */
-/*   CompactSignWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *pk ) */
-/*     : SignWorker(callback, msg, pk){} */
-
-/*   void Execute () { */
-/*     this->result = secp256k1_ecdsa_sign_compact(this->msg, this->sig , this->pk, NULL, NULL,  &this->sig_len); */
-/*   } */
-
-/*   void HandleOKCallback () { */
-/*     NanScope(); */
-/*     Handle<Value> argv[] = { */
-/*       NanNew<Number>(this->result), */
-/*       NanNewBufferHandle((char *)this->sig, 64), */
-/*       NanNew<Number>(this->sig_len) */
-/*     }; */
-/*     callback->Call(3, argv); */
-/*   } */
-/* }; */
-
-/* class RecoverWorker : public NanAsyncWorker { */
-/*  public: */
-/*   // Constructor */
-/*   RecoverWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int compressed, int rec_id) */
-/*     : NanAsyncWorker(callback), msg(msg), sig(sig), compressed(compressed), rec_id(rec_id) {} */
-/*   // Destructor */
-/*   ~RecoverWorker() {} */
-
-/*   void Execute () { */
-/*     if(this->compressed == 1){ */
-/*       this->pubkey = new unsigned char[33]; */ 
-/*     }else{ */
-/*       this->pubkey = new unsigned char[65]; */ 
-/*     } */
-
-/*     this->result = secp256k1_ecdsa_recover_compact(this->msg, this->sig, this->pubkey, &this->pubkey_len, this->compressed, this->rec_id); */
-/*   } */
-
-/*   void HandleOKCallback () { */
-/*     NanScope(); */
-/*     Handle<Value> argv[] = { */
-/*       NanNew<Number>(this->result), */
-/*       NanNewBufferHandle((char *)this->pubkey, this->pubkey_len) */
-/*     }; */
-/*     callback->Call(2, argv); */
-/*   } */
-
-/*  protected: */
-/*   const unsigned char * msg; */
-/*   const unsigned char * sig; */ 
-/*   int compressed; */
-/*   int rec_id; */
-/*   int result; */
-/*   unsigned char * pubkey; */
-/*   int pubkey_len; */
-/* }; */
-
-/* class VerifyWorker : public NanAsyncWorker { */
-/*  public: */
-/*   // Constructor */
-/*   VerifyWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int sig_len, const unsigned char *pub_key, int pub_key_len) */
-/*     : NanAsyncWorker(callback), msg(msg), sig(sig), sig_len(sig_len), pub_key(pub_key), pub_key_len(pub_key_len) {} */
-/*   // Destructor */
-/*   ~VerifyWorker() {} */
-
-/*   void Execute () { */
-/*     this->result = secp256k1_ecdsa_verify(this->msg, this->sig, this->sig_len,  this->pub_key, this->pub_key_len); */
-/*   } */
-
-/*   void HandleOKCallback () { */
-/*     NanScope(); */
-/*     Handle<Value> argv[] = { */
-/*       NanNew<Number>(this->result), */
-/*     }; */
-/*     callback->Call(1, argv); */
-/*   } */
-
-/*  protected: */
-/*   int result; */
-/*   const unsigned char * msg; */
-/*   const unsigned char * sig; */
-/*   int sig_len; */ 
-/*   const unsigned char * pub_key; */
-/*   int pub_key_len; */
-/* }; */
-
-/* NAN_METHOD(Verify){ */
-/*   NanScope(); */
-
-/*   Local<Object> pub_buf = args[0].As<Object>(); */
-/*   const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */
-/*   int pub_len = node::Buffer::Length(args[0]); */
-
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-
-/*   Local<Object> sig_buf = args[2].As<Object>(); */
-/*   const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */
-/*   int sig_len = node::Buffer::Length(args[2]); */
-
-/*   int result = secp256k1_ecdsa_verify(msg_data, sig_data, sig_len, pub_data, pub_len ); */ 
-
-/*   NanReturnValue(NanNew<Number>(result)); */
-/* } */
-
-/* NAN_METHOD(Verify_Async){ */
-/*   NanScope(); */
-
-/*   Local<Object> pub_buf = args[0].As<Object>(); */
-/*   const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */
-/*   int pub_len = node::Buffer::Length(args[0]); */
-
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-
-/*   Local<Object> sig_buf = args[2].As<Object>(); */
-/*   const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */
-/*   int sig_len = node::Buffer::Length(args[2]); */
-
-/*   Local<Function> callback = args[3].As<Function>(); */
-/*   NanCallback* nanCallback = new NanCallback(callback); */
-
-/*   VerifyWorker* worker = new VerifyWorker(nanCallback, msg_data, sig_data, sig_len, pub_data, pub_len); */
-/*   NanAsyncQueueWorker(worker); */
-
-/*   NanReturnUndefined(); */
-/* } */
-
-/* NAN_METHOD(Sign){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Local<Object> pk_buf = args[0].As<Object>(); */
-/*   const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */
-/*   int sec_len = node::Buffer::Length(args[0]); */
-/*   //the second argument is the message that we are signing */
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-
-/*   unsigned char sig[72]; */
-/*   int sig_len = 72; */
-/*   int msg_len = node::Buffer::Length(args[1]); */
-
-/*   if(sec_len != 32){ */
-/*     return NanThrowError("the secret key needs tobe 32 bytes"); */
-/*   } */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   int result = secp256k1_ecdsa_sign(msg_data, sig , &sig_len, pk_data, NULL, NULL); */
-
-/*   if(result == 1){ */
-/*     NanReturnValue(NanNewBufferHandle((char *)sig, sig_len)); */
-/*   }else{ */
-/*     return NanThrowError("nonce invalid, try another one"); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Sign_Async){ */
-
-/*   NanScope(); */
-/*   //the first argument should be the private key as a buffer */
-/*   Local<Object> sec_buf = args[0].As<Object>(); */
-/*   const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */
-/*   int sec_len = node::Buffer::Length(args[0]); */
-/*   //the second argument is the message that we are signing */
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-
-/*   Local<Function> callback = args[2].As<Function>(); */
-/*   NanCallback* nanCallback = new NanCallback(callback); */
-
-/*   int msg_len = node::Buffer::Length(args[1]); */
-
-/*   if(sec_len != 32){ */
-/*     return NanThrowError("the secret key needs tobe 32 bytes"); */
-/*   } */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   SignWorker* worker = new SignWorker(nanCallback, msg_data, sec_data); */
-/*   NanAsyncQueueWorker(worker); */
-
-/*   NanReturnUndefined(); */
-/* } */
-
-/* NAN_METHOD(Sign_Compact){ */
-
-/*   NanScope(); */
-
-/*   Local<Object> seckey_buf = args[0].As<Object>(); */
-/*   const unsigned char *seckey_data = (unsigned char *) node::Buffer::Data(seckey_buf); */
-/*   int sec_len = node::Buffer::Length(args[0]); */
-
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-/*   int msg_len = node::Buffer::Length(args[1]); */
-
-/*   if(sec_len != 32){ */
-/*     return NanThrowError("the secret key needs tobe 32 bytes"); */
-/*   } */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   unsigned char sig[64]; */
-/*   int rec_id; */
-
-/*   //TODO: change the nonce */
-/*   int valid_nonce = secp256k1_ecdsa_sign_compact(msg_data, sig, seckey_data, NULL, NULL, &rec_id ); */
-
-/*   Local<Array> array = NanNew<Array>(3); */
-/*   array->Set(0, NanNew<Integer>(valid_nonce)); */
-/*   array->Set(1, NanNew<Integer>(rec_id)); */
-/*   array->Set(2, NanNewBufferHandle((char *)sig, 64)); */
-
-/*   NanReturnValue(array); */
-/* } */
-
-/* NAN_METHOD(Sign_Compact_Async){ */
-/*   NanScope(); */
-/*   //the first argument should be the private key as a buffer */
-/*   Local<Object> sec_buf = args[0].As<Object>(); */
-/*   const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */
-/*   int sec_len = node::Buffer::Length(args[0]); */
-
-/*   //the second argument is the message that we are signing */
-/*   Local<Object> msg_buf = args[1].As<Object>(); */
-/*   const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */
-
-
-/*   Local<Function> callback = args[2].As<Function>(); */
-/*   NanCallback* nanCallback = new NanCallback(callback); */
-
-/*   int msg_len = node::Buffer::Length(args[1]); */
-
-/*   if(sec_len != 32){ */
-/*     return NanThrowError("the secret key needs tobe 32 bytes"); */
-/*   } */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   CompactSignWorker* worker = new CompactSignWorker(nanCallback, msg_data, sec_data); */ 
-/*   NanAsyncQueueWorker(worker); */
-
-/*   NanReturnUndefined(); */
-/* } */
-
-/* NAN_METHOD(Recover_Compact){ */
-
-/*   NanScope(); */
-  
-/*   Local<Object> msg_buf = args[0].As<Object>(); */
-/*   const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */
-/*   int msg_len = node::Buffer::Length(args[0]); */
-
-/*   Local<Object> sig_buf = args[1].As<Object>(); */
-/*   const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */
-
-/*   Local<Number> compressed = args[2].As<Number>(); */
-/*   int int_compressed = compressed->IntegerValue(); */
-
-/*   Local<Number> rec_id = args[3].As<Number>(); */
-/*   int int_rec_id = rec_id->IntegerValue(); */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   unsigned char pubKey[65]; */ 
-
-/*   int pubKeyLen; */
-
-/*   int result = secp256k1_ecdsa_recover_compact(msg, sig, pubKey, &pubKeyLen, int_compressed, int_rec_id); */
-/*   if(result == 1){ */
-/*     NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */
-/*   }else{ */
-    
-/*     NanReturnValue(NanFalse()); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Recover_Compact_Async){ */
-
-/*   NanScope(); */
-  
-/*   //the message */
-/*   Local<Object> msg_buf = args[0].As<Object>(); */
-/*   const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */
-/*   int msg_len = node::Buffer::Length(args[0]); */
-
-/*   //the signature length */
-/*   Local<Object> sig_buf = args[1].As<Object>(); */
-/*   const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */
-/*   //todo sig len needs tobe 64 */
-/*   int sig_len = node::Buffer::Length(args[1]); */
-
-/*   //to compress or not? */
-/*   Local<Number> compressed = args[2].As<Number>(); */
-/*   int int_compressed = compressed->IntegerValue(); */
-
-/*   //the rec_id */
-/*   Local<Number> rec_id = args[3].As<Number>(); */
-/*   int int_rec_id = rec_id->IntegerValue(); */
-
-/*   //the callback */
-/*   Local<Function> callback = args[4].As<Function>(); */
-/*   NanCallback* nanCallback = new NanCallback(callback); */
-
-/*   if(sig_len != 64){ */
-/*     return NanThrowError("the signature needs to be 64 bytes"); */
-/*   } */
-
-/*   if(msg_len == 0){ */
-/*     return NanThrowError("messgae cannot be null"); */ 
-/*   } */
-
-/*   RecoverWorker* worker = new RecoverWorker(nanCallback, msg, sig, int_compressed, int_rec_id); */
-/*   NanAsyncQueueWorker(worker); */
-
-/*   NanReturnUndefined(); */
-/* } */
-
-/* NAN_METHOD(Seckey_Verify){ */
-/*   NanScope(); */
-
-/*   const unsigned char *data = (const unsigned char*) node::Buffer::Data(args[0]); */
-/*   int result =  secp256k1_ec_seckey_verify(data); */ 
-/*   NanReturnValue(NanNew<Number>(result)); */ 
-/* } */
-
-/* NAN_METHOD(Pubkey_Verify){ */
-
-/*   NanScope(); */
-  
-/*   Local<Object> pub_buf = args[0].As<Object>(); */
-/*   const unsigned char *pub_key = (unsigned char *) node::Buffer::Data(pub_buf); */
-/*   int pub_key_len = node::Buffer::Length(args[0]); */
-
-/*   int result = secp256k1_ec_pubkey_verify(pub_key, pub_key_len); */
-
-/*   NanReturnValue(NanNew<Number>(result)); */ 
-/* } */
-
-/* NAN_METHOD(Pubkey_Create){ */
-/*   NanScope(); */
-
-/*   Handle<Object> pk_buf = args[0].As<Object>(); */
-/*   const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */
-/*   int pk_len = node::Buffer::Length(args[0]); */
-
-/*   Local<Number> l_compact = args[1].As<Number>(); */
-/*   int compact = l_compact->IntegerValue(); */
-/*   int pubKeyLen; */
-
-/*   if(pk_len != 32){ */
-/*     return NanThrowError("the secert key need to be 32 bytes"); */
-/*   } */
-
-/*   unsigned char *pubKey; */
-/*   if(compact == 1){ */
-/*     pubKey = new unsigned char[33]; */ 
-/*   }else{ */
-/*     pubKey = new unsigned char[65]; */ 
-/*   } */
-
-/*   int results = secp256k1_ec_pubkey_create(pubKey,&pubKeyLen, pk_data, compact ); */
-/*   if(results == 0){ */
-/*     return NanThrowError("secret was invalid, try again."); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Pubkey_Decompress){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Local<Object> pk_buf = args[0].As<Object>(); */
-/*   unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */
-
-/*   int pk_len = node::Buffer::Length(args[0]); */
-
-/*   int results = secp256k1_ec_pubkey_decompress(pk_data, &pk_len); */
-
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid public key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)pk_data, pk_len)); */
-/*   } */
-/* } */
-
-
-/* NAN_METHOD(Privkey_Import){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> pk_buf = args[0].As<Object>(); */
-/*   const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */
-
-/*   int pk_len = node::Buffer::Length(args[0]); */
-
-/*   unsigned char sec_key[32]; */
-/*   int results = secp256k1_ec_privkey_import(sec_key, pk_data, pk_len); */
-
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid private key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)sec_key, 32)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Privkey_Export){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> sk_buf = args[0].As<Object>(); */
-/*   const unsigned char *sk_data = (unsigned char *) node::Buffer::Data(sk_buf); */
-
-/*   Local<Number> l_compressed = args[1].As<Number>(); */
-/*   int compressed = l_compressed->IntegerValue(); */
-
-/*   unsigned char *privKey; */
-/*   int pk_len; */
-/*   int results = secp256k1_ec_privkey_export(sk_data, privKey, &pk_len, compressed); */
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid private key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)privKey, pk_len)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Privkey_Tweak_Add){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> sk_buf = args[0].As<Object>(); */
-/*   unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */
-
-/*   Handle<Object> tweak_buf = args[1].As<Object>(); */
-/*   const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */
-
-/*   int results = secp256k1_ec_privkey_tweak_add(sk, tweak); */
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Privkey_Tweak_Mul){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> sk_buf = args[0].As<Object>(); */
-/*   unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */
-
-/*   Handle<Object> tweak_buf = args[1].As<Object>(); */
-/*   const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */
-
-/*   int results = secp256k1_ec_privkey_tweak_mul(sk, tweak); */
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Pubkey_Tweak_Add){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> pk_buf = args[0].As<Object>(); */
-/*   unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */
-/*   int pk_len = node::Buffer::Length(args[0]); */
-
-/*   Handle<Object> tweak_buf = args[1].As<Object>(); */
-/*   const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */
-
-/*   int results = secp256k1_ec_pubkey_tweak_add(pk, pk_len, tweak); */
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */
-/*   } */
-/* } */
-
-/* NAN_METHOD(Pubkey_Tweak_Mul){ */
-/*   NanScope(); */
-
-/*   //the first argument should be the private key as a buffer */
-/*   Handle<Object> pk_buf = args[0].As<Object>(); */
-/*   unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */
-/*   int pk_len = node::Buffer::Length(args[0]); */
-
-/*   Handle<Object> tweak_buf = args[1].As<Object>(); */
-/*   const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */
-
-/*   int results = secp256k1_ec_pubkey_tweak_mul(pk, pk_len, tweak); */
-/*   if(results == 0){ */
-/*     return NanThrowError("invalid key"); */
-/*   }else{ */
-/*     NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */
-/*   } */
-/* } */
-
-void Init(Handle<Object> exports) {
-
-  /* secp256k1_start(SECP256K1_START_SIGN | SECP256K1_START_VERIFY); */
-  /* exports->Set(NanNew("seckeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */
-  /* exports->Set(NanNew("sign"), NanNew<FunctionTemplate>(Sign)->GetFunction()); */
-  /* exports->Set(NanNew("signAsync"), NanNew<FunctionTemplate>(Sign_Async)->GetFunction()); */
-  /* exports->Set(NanNew("signCompact"), NanNew<FunctionTemplate>(Sign_Compact)->GetFunction()); */
-  /* exports->Set(NanNew("signCompactAsync"), NanNew<FunctionTemplate>(Sign_Compact_Async)->GetFunction()); */
-  /* exports->Set(NanNew("recoverCompact"), NanNew<FunctionTemplate>(Recover_Compact)->GetFunction()); */
-  /* exports->Set(NanNew("recoverCompactAsync"), NanNew<FunctionTemplate>(Recover_Compact_Async)->GetFunction()); */
-  /* exports->Set(NanNew("verify"), NanNew<FunctionTemplate>(Verify)->GetFunction()); */
-  /* exports->Set(NanNew("verifyAsync"), NanNew<FunctionTemplate>(Verify_Async)->GetFunction()); */
-  /* exports->Set(NanNew("secKeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */
-  /* exports->Set(NanNew("pubKeyVerify"), NanNew<FunctionTemplate>(Pubkey_Verify)->GetFunction()); */
-  /* exports->Set(NanNew("pubKeyCreate"), NanNew<FunctionTemplate>(Pubkey_Create)->GetFunction()); */
-  /* exports->Set(NanNew("pubKeyDecompress"), NanNew<FunctionTemplate>(Pubkey_Decompress)->GetFunction()); */
-  /* exports->Set(NanNew("privKeyExport"), NanNew<FunctionTemplate>(Privkey_Export)->GetFunction()); */
-  /* exports->Set(NanNew("privKeyImport"), NanNew<FunctionTemplate>(Privkey_Import)->GetFunction()); */
-  /* exports->Set(NanNew("privKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */
-  /* exports->Set(NanNew("privKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */
-  /* exports->Set(NanNew("pubKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */
-  /* exports->Set(NanNew("pubKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */
-}
-
-NODE_MODULE(secp256k1, Init)

Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "node-ethash",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "install": "node-gyp rebuild"
-  },
-  "author": "",
-  "license": "ISC",
-  "gypfile": true
-}

Godeps/_workspace/src/github.com/ethereum/ethash/node-ethash/readme.md

@@ -1,12 +0,0 @@
-# To Develop
-`npm install -g node-gyp`  
-`npm install .`  
-
-
-# To rebuild 
-`node-gyp rebuild`  
-
-
-# notes
-
-nan is good https://github.com/rvagg/nan

Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/.gitignore

@@ -0,0 +1,2 @@
+pyethash.egg-info/
+*.so

Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/__init__.py

@@ -0,0 +1,3 @@
+import pyethash.core
+core = pyethash.core
+EPOCH_LENGTH = 30000

Godeps/_workspace/src/github.com/ethereum/ethash/setup.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+from distutils.core import setup, Extension
+ 
+pyethash_core = Extension('pyethash.core', 
+        sources = [
+            'src/python/core.c', 
+            'src/libethash/util.c', 
+            'src/libethash/internal.c',
+            'src/libethash/sha3.c'
+            ],
+        extra_compile_args = ["-std=gnu99"])
+ 
+setup (
+       name = 'pyethash',
+       author = "Matthew Wampler-Doty",
+       author_email = "matthew.wampler.doty@gmail.com",
+       license = 'GPL',
+       version = '1.0',
+       description = 'Python wrappers for ethash, the ethereum proof of work hashing function',
+       ext_modules = [pyethash_core],
+      )

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt

@@ -0,0 +1,15 @@
+set(LIBRARY ethash-cl)
+set(CMAKE_BUILD_TYPE Release)
+
+include(bin2h.cmake)
+bin2h(SOURCE_FILE ethash_cl_miner_kernel.cl VARIABLE_NAME ethash_cl_miner_kernel HEADER_FILE ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h)
+
+if (NOT OpenCL_FOUND)
+	find_package(OpenCL)
+endif()
+if (OpenCL_FOUND)
+	include_directories(${OpenCL_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+	include_directories(..)
+	add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h)
+	TARGET_LINK_LIBRARIES(${LIBRARY} ${OpenCL_LIBRARIES} ethash)
+endif()

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/bin2h.cmake

@@ -0,0 +1,87 @@
+# https://gist.github.com/sivachandran/3a0de157dccef822a230
+include(CMakeParseArguments)
+
+# Function to wrap a given string into multiple lines at the given column position.
+# Parameters:
+#   VARIABLE    - The name of the CMake variable holding the string.
+#   AT_COLUMN   - The column position at which string will be wrapped.
+function(WRAP_STRING)
+    set(oneValueArgs VARIABLE AT_COLUMN)
+    cmake_parse_arguments(WRAP_STRING "${options}" "${oneValueArgs}" "" ${ARGN})
+
+    string(LENGTH ${${WRAP_STRING_VARIABLE}} stringLength)
+    math(EXPR offset "0")
+
+    while(stringLength GREATER 0)
+
+        if(stringLength GREATER ${WRAP_STRING_AT_COLUMN})
+            math(EXPR length "${WRAP_STRING_AT_COLUMN}")
+        else()
+            math(EXPR length "${stringLength}")
+        endif()
+
+        string(SUBSTRING ${${WRAP_STRING_VARIABLE}} ${offset} ${length} line)
+        set(lines "${lines}\n${line}")
+
+        math(EXPR stringLength "${stringLength} - ${length}")
+        math(EXPR offset "${offset} + ${length}")
+    endwhile()
+
+    set(${WRAP_STRING_VARIABLE} "${lines}" PARENT_SCOPE)
+endfunction()
+
+# Function to embed contents of a file as byte array in C/C++ header file(.h). The header file
+# will contain a byte array and integer variable holding the size of the array.
+# Parameters
+#   SOURCE_FILE     - The path of source file whose contents will be embedded in the header file.
+#   VARIABLE_NAME   - The name of the variable for the byte array. The string "_SIZE" will be append
+#                     to this name and will be used a variable name for size variable.
+#   HEADER_FILE     - The path of header file.
+#   APPEND          - If specified appends to the header file instead of overwriting it
+#   NULL_TERMINATE  - If specified a null byte(zero) will be append to the byte array. This will be
+#                     useful if the source file is a text file and we want to use the file contents
+#                     as string. But the size variable holds size of the byte array without this
+#                     null byte.
+# Usage:
+#   bin2h(SOURCE_FILE "Logo.png" HEADER_FILE "Logo.h" VARIABLE_NAME "LOGO_PNG")
+function(BIN2H)
+    set(options APPEND NULL_TERMINATE)
+    set(oneValueArgs SOURCE_FILE VARIABLE_NAME HEADER_FILE)
+    cmake_parse_arguments(BIN2H "${options}" "${oneValueArgs}" "" ${ARGN})
+
+    # reads source file contents as hex string
+    file(READ ${BIN2H_SOURCE_FILE} hexString HEX)
+    string(LENGTH ${hexString} hexStringLength)
+
+    # appends null byte if asked
+    if(BIN2H_NULL_TERMINATE)
+        set(hexString "${hexString}00")
+    endif()
+
+    # wraps the hex string into multiple lines at column 32(i.e. 16 bytes per line)
+    wrap_string(VARIABLE hexString AT_COLUMN 32)
+    math(EXPR arraySize "${hexStringLength} / 2")
+
+    # adds '0x' prefix and comma suffix before and after every byte respectively
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1, " arrayValues ${hexString})
+    # removes trailing comma
+    string(REGEX REPLACE ", $" "" arrayValues ${arrayValues})
+
+    # converts the variable name into proper C identifier
+    # TODO: fix for legacy cmake
+    IF (${CMAKE_VERSION} GREATER 2.8.10)
+        string(MAKE_C_IDENTIFIER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME)
+    ENDIF()
+    string(TOUPPER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME)
+
+    # declares byte array and the length variables
+    set(arrayDefinition "const unsigned char ${BIN2H_VARIABLE_NAME}[] = { ${arrayValues} };")
+    set(arraySizeDefinition "const size_t ${BIN2H_VARIABLE_NAME}_SIZE = ${arraySize};")
+
+    set(declarations "${arrayDefinition}\n\n${arraySizeDefinition}\n\n")
+    if(BIN2H_APPEND)
+        file(APPEND ${BIN2H_HEADER_FILE} "${declarations}")
+    else()
+        file(WRITE ${BIN2H_HEADER_FILE} "${declarations}")
+    endif()
+endfunction()

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp

@@ -0,0 +1,289 @@
+/*
+  This file is part of c-ethash.
+
+  c-ethash is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  c-ethash is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file ethash_cl_miner.cpp
+* @author Tim Hughes <tim@twistedfury.com>
+* @date 2015
+*/
+
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <assert.h>
+#include <queue>
+#include "ethash_cl_miner.h"
+#include "ethash_cl_miner_kernel.h"
+#include <libethash/util.h>
+
+#undef min
+#undef max
+
+#define HASH_BYTES 32
+
+static void add_definition(std::string& source, char const* id, unsigned value)
+{
+	char buf[256];
+	sprintf(buf, "#define %s %uu\n", id, value);
+	source.insert(source.begin(), buf, buf + strlen(buf));
+}
+
+ethash_cl_miner::ethash_cl_miner()
+{
+}
+
+bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size)
+{
+	// store params
+	m_params = params;
+
+	// get all platforms
+    std::vector<cl::Platform> platforms;
+    cl::Platform::get(&platforms);
+	if (platforms.empty())
+	{
+		debugf("No OpenCL platforms found.\n");
+		return false;
+	}
+
+	// use default platform
+	debugf("Using platform: %s\n", platforms[0].getInfo<CL_PLATFORM_NAME>().c_str());
+
+    // get GPU device of the default platform
+    std::vector<cl::Device> devices;
+    platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices);
+    if (devices.empty())
+	{
+		debugf("No OpenCL devices found.\n");
+		return false;
+	}
+
+	// use default device
+	cl::Device& device = devices[0];
+	debugf("Using device: %s\n", device.getInfo<CL_DEVICE_NAME>().c_str());
+
+	// create context
+	m_context = cl::Context({device});
+	m_queue = cl::CommandQueue(m_context, device);
+
+	// use requested workgroup size, but we require multiple of 8
+	m_workgroup_size = ((workgroup_size + 7) / 8) * 8;
+
+	// patch source code
+	std::string code(ETHASH_CL_MINER_KERNEL, ETHASH_CL_MINER_KERNEL + ETHASH_CL_MINER_KERNEL_SIZE);
+	add_definition(code, "GROUP_SIZE", m_workgroup_size);
+	add_definition(code, "DAG_SIZE", (unsigned)(params.full_size / MIX_BYTES));
+	add_definition(code, "ACCESSES", ACCESSES);
+	add_definition(code, "MAX_OUTPUTS", c_max_search_results);
+	//debugf("%s", code.c_str());
+
+	// create miner OpenCL program
+	cl::Program::Sources sources;
+	sources.push_back({code.c_str(), code.size()});
+
+	cl::Program program(m_context, sources);
+	try
+	{
+		program.build({device});
+	}
+	catch (cl::Error err)
+	{
+		debugf("%s\n", program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device).c_str());
+		return false;
+	}
+	m_hash_kernel = cl::Kernel(program, "ethash_hash");
+	m_search_kernel = cl::Kernel(program, "ethash_search");
+
+	// create buffer for dag
+	m_dag = cl::Buffer(m_context, CL_MEM_READ_ONLY, params.full_size);
+	
+	// create buffer for header
+	m_header = cl::Buffer(m_context, CL_MEM_READ_ONLY, 32);
+
+	// compute dag on CPU
+	{
+		void* cache_mem = malloc(params.cache_size + 63);
+		ethash_cache cache;
+		cache.mem = (void*)(((uintptr_t)cache_mem + 63) & ~63);
+		ethash_mkcache(&cache, &params, seed);
+
+		// if this throws then it's because we probably need to subdivide the dag uploads for compatibility
+		void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, CL_MAP_WRITE_INVALIDATE_REGION, 0, params.full_size);
+		ethash_compute_full_data(dag_ptr, &params, &cache);
+		m_queue.enqueueUnmapMemObject(m_dag, dag_ptr);
+
+		free(cache_mem);
+	}
+
+	// create mining buffers
+	for (unsigned i = 0; i != c_num_buffers; ++i)
+	{
+		m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, 32*c_hash_batch_size);
+		m_search_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY, (c_max_search_results + 1) * sizeof(uint32_t));
+	}
+	return true;
+}
+
+void ethash_cl_miner::hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count)
+{
+	struct pending_batch
+	{
+		unsigned base;
+		unsigned count;
+		unsigned buf;
+	};
+	std::queue<pending_batch> pending;
+	
+	// update header constant buffer
+	m_queue.enqueueWriteBuffer(m_header, true, 0, 32, header);
+
+	/*
+	__kernel void ethash_combined_hash(
+		__global hash32_t* g_hashes,
+		__constant hash32_t const* g_header,
+		__global hash128_t const* g_dag,
+		ulong start_nonce,
+		uint isolate
+		)
+	*/
+	m_hash_kernel.setArg(1, m_header);
+	m_hash_kernel.setArg(2, m_dag);
+	m_hash_kernel.setArg(3, nonce);
+	m_hash_kernel.setArg(4, ~0u); // have to pass this to stop the compile unrolling the loop
+
+	unsigned buf = 0;
+	for (unsigned i = 0; i < count || !pending.empty(); )
+	{
+		// how many this batch
+		if (i < count)
+		{
+			unsigned const this_count = std::min(count - i, c_hash_batch_size);
+			unsigned const batch_count = std::max(this_count, m_workgroup_size);
+
+			// supply output hash buffer to kernel
+			m_hash_kernel.setArg(0, m_hash_buf[buf]);
+
+			// execute it!
+			clock_t start_time = clock();
+			m_queue.enqueueNDRangeKernel(
+				m_hash_kernel,
+				cl::NullRange,
+				cl::NDRange(batch_count),
+				cl::NDRange(m_workgroup_size)
+				);
+			m_queue.flush();
+		
+			pending.push({i, this_count, buf});
+			i += this_count;
+			buf = (buf + 1) % c_num_buffers;
+		}
+
+		// read results
+		if (i == count || pending.size() == c_num_buffers)
+		{
+			pending_batch const& batch = pending.front();
+
+			// could use pinned host pointer instead, but this path isn't that important.
+			uint8_t* hashes = (uint8_t*)m_queue.enqueueMapBuffer(m_hash_buf[batch.buf], true, CL_MAP_READ, 0, batch.count * HASH_BYTES);
+			memcpy(ret + batch.base*HASH_BYTES, hashes, batch.count*HASH_BYTES);
+			m_queue.enqueueUnmapMemObject(m_hash_buf[batch.buf], hashes);
+
+			pending.pop();
+		}
+	}
+}
+
+
+void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook& hook)
+{
+	struct pending_batch
+	{
+		uint64_t start_nonce;
+		unsigned buf;
+	};
+	std::queue<pending_batch> pending;
+
+	static uint32_t const c_zero = 0;
+
+	// update header constant buffer
+	m_queue.enqueueWriteBuffer(m_header, false, 0, 32, header);
+	for (unsigned i = 0; i != c_num_buffers; ++i)
+	{
+		m_queue.enqueueWriteBuffer(m_search_buf[i], false, 0, 4, &c_zero);
+	}
+	cl::Event pre_return_event;
+	m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event);
+
+	/*
+	__kernel void ethash_combined_search(
+		__global hash32_t* g_hashes,			// 0
+		__constant hash32_t const* g_header,	// 1
+		__global hash128_t const* g_dag,		// 2
+		ulong start_nonce,						// 3
+		ulong target,							// 4
+		uint isolate							// 5
+	)
+	*/
+	m_search_kernel.setArg(1, m_header);
+	m_search_kernel.setArg(2, m_dag);
+
+	// pass these to stop the compiler unrolling the loops
+	m_search_kernel.setArg(4, target);
+	m_search_kernel.setArg(5, ~0u);
+
+
+	unsigned buf = 0;
+	for (uint64_t start_nonce = 0; ; start_nonce += c_search_batch_size)
+	{
+		// supply output buffer to kernel
+		m_search_kernel.setArg(0, m_search_buf[buf]);
+		m_search_kernel.setArg(3, start_nonce);
+
+		// execute it!
+		m_queue.enqueueNDRangeKernel(m_search_kernel, cl::NullRange, c_search_batch_size, m_workgroup_size);
+		
+		pending.push({start_nonce, buf});
+		buf = (buf + 1) % c_num_buffers;
+
+		// read results
+		if (pending.size() == c_num_buffers)
+		{
+			pending_batch const& batch = pending.front();
+
+			// could use pinned host pointer instead
+			uint32_t* results = (uint32_t*)m_queue.enqueueMapBuffer(m_search_buf[batch.buf], true, CL_MAP_READ, 0, (1+c_max_search_results) * sizeof(uint32_t));
+			unsigned num_found = std::min(results[0], c_max_search_results);
+
+			uint64_t nonces[c_max_search_results];
+			for (unsigned i = 0; i != num_found; ++i)
+			{
+				nonces[i] = batch.start_nonce + results[i+1];
+			}
+			
+			m_queue.enqueueUnmapMemObject(m_search_buf[batch.buf], results);
+			
+			bool exit = num_found && hook.found(nonces, num_found);
+			exit |= hook.searched(batch.start_nonce, c_search_batch_size); // always report searched before exit
+			if (exit)
+				break;
+
+			pending.pop();
+		}
+	}
+
+	// not safe to return until this is ready
+	pre_return_event.wait();
+}
+

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner_kernel.cl

@@ -1,39 +1,3 @@
-/*
-  This file is part of c-ethash.
-
-  c-ethash is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  c-ethash is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/** @file ethash_cl_miner.cpp
-* @author Tim Hughes <tim@twistedfury.com>
-* @date 2015
-*/
-
-
-#define _CRT_SECURE_NO_WARNINGS
-
-#include <assert.h>
-#include <queue>
-#include "ethash_cl_miner.h"
-#include <libethash/util.h>
-
-#undef min
-#undef max
-
-#define HASH_BYTES 32
-
-static char const ethash_inner_code[] = R"(
-
 // author Tim Hughes <tim@twistedfury.com>
 // Tested on Radeon HD 7850
 // Hashrate: 15940347 hashes/s
@@ -495,260 +459,3 @@ __kernel void ethash_search(
 		g_output[slot] = gid;
 	}
 }
-
-)";
-
-static void add_definition(std::string& source, char const* id, unsigned value)
-{
-	char buf[256];
-	sprintf(buf, "#define %s %uu\n", id, value);
-	source.insert(source.begin(), buf, buf + strlen(buf));
-}
-
-ethash_cl_miner::ethash_cl_miner()
-{
-}
-
-bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size)
-{
-	// store params
-	m_params = params;
-
-	// get all platforms
-    std::vector<cl::Platform> platforms;
-    cl::Platform::get(&platforms);
-	if (platforms.empty())
-	{
-		debugf("No OpenCL platforms found.\n");
-		return false;
-	}
-
-	// use default platform
-	debugf("Using platform: %s\n", platforms[0].getInfo<CL_PLATFORM_NAME>().c_str());
-
-    // get GPU device of the default platform
-    std::vector<cl::Device> devices;
-    platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices);
-    if (devices.empty())
-	{
-		debugf("No OpenCL devices found.\n");
-		return false;
-	}
-
-	// use default device
-	cl::Device& device = devices[0];
-	debugf("Using device: %s\n", device.getInfo<CL_DEVICE_NAME>().c_str());
-
-	// create context
-	m_context = cl::Context({device});
-	m_queue = cl::CommandQueue(m_context, device);
-
-	// use requested workgroup size, but we require multiple of 8
-	m_workgroup_size = ((workgroup_size + 7) / 8) * 8;
-
-	// patch source code
-	std::string code = ethash_inner_code;
-	add_definition(code, "GROUP_SIZE", m_workgroup_size);
-	add_definition(code, "DAG_SIZE", (unsigned)(params.full_size / MIX_BYTES));
-	add_definition(code, "ACCESSES", ACCESSES);
-	add_definition(code, "MAX_OUTPUTS", c_max_search_results);
-	//debugf("%s", code.c_str());
-
-	// create miner OpenCL program
-	cl::Program::Sources sources;
-	sources.push_back({code.c_str(), code.size()});
-
-	cl::Program program(m_context, sources);
-	try
-	{
-		program.build({device});
-	}
-	catch (cl::Error err)
-	{
-		debugf("%s\n", program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device).c_str());
-		return false;
-	}
-	m_hash_kernel = cl::Kernel(program, "ethash_hash");
-	m_search_kernel = cl::Kernel(program, "ethash_search");
-
-	// create buffer for dag
-	m_dag = cl::Buffer(m_context, CL_MEM_READ_ONLY, params.full_size);
-	
-	// create buffer for header
-	m_header = cl::Buffer(m_context, CL_MEM_READ_ONLY, 32);
-
-	// compute dag on CPU
-	{
-		void* cache_mem = malloc(params.cache_size + 63);
-		ethash_cache cache;
-		cache.mem = (void*)(((uintptr_t)cache_mem + 63) & ~63);
-		ethash_mkcache(&cache, &params, seed);
-
-		// if this throws then it's because we probably need to subdivide the dag uploads for compatibility
-		void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, CL_MAP_WRITE_INVALIDATE_REGION, 0, params.full_size);
-		ethash_compute_full_data(dag_ptr, &params, &cache);
-		m_queue.enqueueUnmapMemObject(m_dag, dag_ptr);
-
-		free(cache_mem);
-	}
-
-	// create mining buffers
-	for (unsigned i = 0; i != c_num_buffers; ++i)
-	{
-		m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, 32*c_hash_batch_size);
-		m_search_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY, (c_max_search_results + 1) * sizeof(uint32_t));
-	}
-	return true;
-}
-
-void ethash_cl_miner::hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count)
-{
-	struct pending_batch
-	{
-		unsigned base;
-		unsigned count;
-		unsigned buf;
-	};
-	std::queue<pending_batch> pending;
-	
-	// update header constant buffer
-	m_queue.enqueueWriteBuffer(m_header, true, 0, 32, header);
-
-	/*
-	__kernel void ethash_combined_hash(
-		__global hash32_t* g_hashes,
-		__constant hash32_t const* g_header,
-		__global hash128_t const* g_dag,
-		ulong start_nonce,
-		uint isolate
-		)
-	*/
-	m_hash_kernel.setArg(1, m_header);
-	m_hash_kernel.setArg(2, m_dag);
-	m_hash_kernel.setArg(3, nonce);
-	m_hash_kernel.setArg(4, ~0u); // have to pass this to stop the compile unrolling the loop
-
-	unsigned buf = 0;
-	for (unsigned i = 0; i < count || !pending.empty(); )
-	{
-		// how many this batch
-		if (i < count)
-		{
-			unsigned const this_count = std::min(count - i, c_hash_batch_size);
-			unsigned const batch_count = std::max(this_count, m_workgroup_size);
-
-			// supply output hash buffer to kernel
-			m_hash_kernel.setArg(0, m_hash_buf[buf]);
-
-			// execute it!
-			clock_t start_time = clock();
-			m_queue.enqueueNDRangeKernel(
-				m_hash_kernel,
-				cl::NullRange,
-				cl::NDRange(batch_count),
-				cl::NDRange(m_workgroup_size)
-				);
-			m_queue.flush();
-		
-			pending.push({i, this_count, buf});
-			i += this_count;
-			buf = (buf + 1) % c_num_buffers;
-		}
-
-		// read results
-		if (i == count || pending.size() == c_num_buffers)
-		{
-			pending_batch const& batch = pending.front();
-
-			// could use pinned host pointer instead, but this path isn't that important.
-			uint8_t* hashes = (uint8_t*)m_queue.enqueueMapBuffer(m_hash_buf[batch.buf], true, CL_MAP_READ, 0, batch.count * HASH_BYTES);
-			memcpy(ret + batch.base*HASH_BYTES, hashes, batch.count*HASH_BYTES);
-			m_queue.enqueueUnmapMemObject(m_hash_buf[batch.buf], hashes);
-
-			pending.pop();
-		}
-	}
-}
-
-
-void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook& hook)
-{
-	struct pending_batch
-	{
-		uint64_t start_nonce;
-		unsigned buf;
-	};
-	std::queue<pending_batch> pending;
-
-	static uint32_t const c_zero = 0;
-
-	// update header constant buffer
-	m_queue.enqueueWriteBuffer(m_header, false, 0, 32, header);
-	for (unsigned i = 0; i != c_num_buffers; ++i)
-	{
-		m_queue.enqueueWriteBuffer(m_search_buf[i], false, 0, 4, &c_zero);
-	}
-	cl::Event pre_return_event;
-	m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event);
-
-	/*
-	__kernel void ethash_combined_search(
-		__global hash32_t* g_hashes,			// 0
-		__constant hash32_t const* g_header,	// 1
-		__global hash128_t const* g_dag,		// 2
-		ulong start_nonce,						// 3
-		ulong target,							// 4
-		uint isolate							// 5
-	)
-	*/
-	m_search_kernel.setArg(1, m_header);
-	m_search_kernel.setArg(2, m_dag);
-
-	// pass these to stop the compiler unrolling the loops
-	m_search_kernel.setArg(4, target);
-	m_search_kernel.setArg(5, ~0u);
-
-
-	unsigned buf = 0;
-	for (uint64_t start_nonce = 0; ; start_nonce += c_search_batch_size)
-	{
-		// supply output buffer to kernel
-		m_search_kernel.setArg(0, m_search_buf[buf]);
-		m_search_kernel.setArg(3, start_nonce);
-
-		// execute it!
-		m_queue.enqueueNDRangeKernel(m_search_kernel, cl::NullRange, c_search_batch_size, m_workgroup_size);
-		
-		pending.push({start_nonce, buf});
-		buf = (buf + 1) % c_num_buffers;
-
-		// read results
-		if (pending.size() == c_num_buffers)
-		{
-			pending_batch const& batch = pending.front();
-
-			// could use pinned host pointer instead
-			uint32_t* results = (uint32_t*)m_queue.enqueueMapBuffer(m_search_buf[batch.buf], true, CL_MAP_READ, 0, (1+c_max_search_results) * sizeof(uint32_t));
-			unsigned num_found = std::min(results[0], c_max_search_results);
-
-			uint64_t nonces[c_max_search_results];
-			for (unsigned i = 0; i != num_found; ++i)
-			{
-				nonces[i] = batch.start_nonce + results[i+1];
-			}
-			
-			m_queue.enqueueUnmapMemObject(m_search_buf[batch.buf], results);
-			
-			bool exit = num_found && hook.found(nonces, num_found);
-			exit |= hook.searched(batch.start_nonce, c_search_batch_size); // always report searched before exit
-			if (exit)
-				break;
-
-			pending.pop();
-		}
-	}
-
-	// not safe to return until this is ready
-	pre_return_event.wait();
-}
-

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/CMakeLists.txt

@@ -1,4 +1,10 @@
 set(LIBRARY ethash)
+
+if (CPPETHEREUM)
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
+#else ()
+endif ()
+
 set(CMAKE_BUILD_TYPE Release)
 
 if (NOT MSVC)

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/data_sizes.h

@@ -0,0 +1,779 @@
+/*
+  This file is part of cpp-ethereum.
+
+  cpp-ethereum is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software FoundationUUU,either version 3 of the LicenseUUU,or
+  (at your option) any later version.
+
+  cpp-ethereum is distributed in the hope that it will be usefulU,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with cpp-ethereum.  If notUUU,see <http://www.gnu.org/licenses/>.
+*/
+
+/** @file data_sizes.h
+* @author Matthew Wampler-Doty <negacthulhu@gmail.com>
+* @date 2015
+*/
+
+// TODO: Update this after ~3.5 years
+
+#pragma once
+
+#include <stdint.h>
+#include "compiler.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+// 2048 Epochs worth of tabulated DAG sizes
+
+// Generated with the following Mathematica Code:
+
+// GetDataSizes[n_] := Module[{
+//        DataSetSizeBytesInit = 2^30,
+//        MixBytes = 128,
+//        DataSetGrowth = 2^23,
+//        j = 0},
+//        Reap[
+//          While[j < n,
+//            Module[{i =
+//              Floor[(DataSetSizeBytesInit + DataSetGrowth * j) / MixBytes]},
+//              While[! PrimeQ[i], i--];
+//              Sow[i*MixBytes]; j++]]]][[2]][[1]]
+
+static const size_t dag_sizes[] = {
+        1073739904U, 1082130304U, 1090514816U, 1098906752U, 1107293056U,
+        1115684224U, 1124070016U, 1132461952U, 1140849536U, 1149232768U,
+        1157627776U, 1166013824U, 1174404736U, 1182786944U, 1191180416U,
+        1199568512U, 1207958912U, 1216345216U, 1224732032U, 1233124736U,
+        1241513344U, 1249902464U, 1258290304U, 1266673792U, 1275067264U,
+        1283453312U, 1291844992U, 1300234112U, 1308619904U, 1317010048U,
+        1325397376U, 1333787776U, 1342176128U, 1350561664U, 1358954368U,
+        1367339392U, 1375731584U, 1384118144U, 1392507008U, 1400897408U,
+        1409284736U, 1417673344U, 1426062464U, 1434451072U, 1442839168U,
+        1451229056U, 1459615616U, 1468006016U, 1476394112U, 1484782976U,
+        1493171584U, 1501559168U, 1509948032U, 1518337664U, 1526726528U,
+        1535114624U, 1543503488U, 1551892096U, 1560278656U, 1568669056U,
+        1577056384U, 1585446272U, 1593831296U, 1602219392U, 1610610304U,
+        1619000192U, 1627386752U, 1635773824U, 1644164224U, 1652555648U,
+        1660943488U, 1669332608U, 1677721216U, 1686109312U, 1694497664U,
+        1702886272U, 1711274624U, 1719661184U, 1728047744U, 1736434816U,
+        1744829056U, 1753218944U, 1761606272U, 1769995904U, 1778382464U,
+        1786772864U, 1795157888U, 1803550592U, 1811937664U, 1820327552U,
+        1828711552U, 1837102976U, 1845488768U, 1853879936U, 1862269312U,
+        1870656896U, 1879048064U, 1887431552U, 1895825024U, 1904212096U,
+        1912601216U, 1920988544U, 1929379456U, 1937765504U, 1946156672U,
+        1954543232U, 1962932096U, 1971321728U, 1979707264U, 1988093056U,
+        1996487552U, 2004874624U, 2013262208U, 2021653888U, 2030039936U,
+        2038430848U, 2046819968U, 2055208576U, 2063596672U, 2071981952U,
+        2080373632U, 2088762752U, 2097149056U, 2105539712U, 2113928576U,
+        2122315136U, 2130700672U, 2139092608U, 2147483264U, 2155872128U,
+        2164257664U, 2172642176U, 2181035392U, 2189426048U, 2197814912U,
+        2206203008U, 2214587264U, 2222979712U, 2231367808U, 2239758208U,
+        2248145024U, 2256527744U, 2264922752U, 2273312128U, 2281701248U,
+        2290086272U, 2298476672U, 2306867072U, 2315251072U, 2323639168U,
+        2332032128U, 2340420224U, 2348808064U, 2357196416U, 2365580416U,
+        2373966976U, 2382363008U, 2390748544U, 2399139968U, 2407530368U,
+        2415918976U, 2424307328U, 2432695424U, 2441084288U, 2449472384U,
+        2457861248U, 2466247808U, 2474637184U, 2483026816U, 2491414144U,
+        2499803776U, 2508191872U, 2516582272U, 2524970368U, 2533359232U,
+        2541743488U, 2550134144U, 2558525056U, 2566913408U, 2575301504U,
+        2583686528U, 2592073856U, 2600467328U, 2608856192U, 2617240448U,
+        2625631616U, 2634022016U, 2642407552U, 2650796416U, 2659188352U,
+        2667574912U, 2675965312U, 2684352896U, 2692738688U, 2701130624U,
+        2709518464U, 2717907328U, 2726293376U, 2734685056U, 2743073152U,
+        2751462016U, 2759851648U, 2768232832U, 2776625536U, 2785017728U,
+        2793401984U, 2801794432U, 2810182016U, 2818571648U, 2826959488U,
+        2835349376U, 2843734144U, 2852121472U, 2860514432U, 2868900992U,
+        2877286784U, 2885676928U, 2894069632U, 2902451584U, 2910843008U,
+        2919234688U, 2927622784U, 2936011648U, 2944400768U, 2952789376U,
+        2961177728U, 2969565568U, 2977951616U, 2986338944U, 2994731392U,
+        3003120256U, 3011508352U, 3019895936U, 3028287104U, 3036675968U,
+        3045063808U, 3053452928U, 3061837696U, 3070228352U, 3078615424U,
+        3087003776U, 3095394944U, 3103782272U, 3112173184U, 3120562048U,
+        3128944768U, 3137339264U, 3145725056U, 3154109312U, 3162505088U,
+        3170893184U, 3179280256U, 3187669376U, 3196056704U, 3204445568U,
+        3212836736U, 3221224064U, 3229612928U, 3238002304U, 3246391168U,
+        3254778496U, 3263165824U, 3271556224U, 3279944576U, 3288332416U,
+        3296719232U, 3305110912U, 3313500032U, 3321887104U, 3330273152U,
+        3338658944U, 3347053184U, 3355440512U, 3363827072U, 3372220288U,
+        3380608384U, 3388997504U, 3397384576U, 3405774208U, 3414163072U,
+        3422551936U, 3430937984U, 3439328384U, 3447714176U, 3456104576U,
+        3464493952U, 3472883584U, 3481268864U, 3489655168U, 3498048896U,
+        3506434432U, 3514826368U, 3523213952U, 3531603584U, 3539987072U,
+        3548380288U, 3556763264U, 3565157248U, 3573545344U, 3581934464U,
+        3590324096U, 3598712704U, 3607098752U, 3615488384U, 3623877248U,
+        3632265856U, 3640646528U, 3649043584U, 3657430144U, 3665821568U,
+        3674207872U, 3682597504U, 3690984832U, 3699367808U, 3707764352U,
+        3716152448U, 3724541056U, 3732925568U, 3741318016U, 3749706368U,
+        3758091136U, 3766481536U, 3774872704U, 3783260032U, 3791650432U,
+        3800036224U, 3808427648U, 3816815488U, 3825204608U, 3833592704U,
+        3841981568U, 3850370432U, 3858755968U, 3867147904U, 3875536256U,
+        3883920512U, 3892313728U, 3900702592U, 3909087872U, 3917478784U,
+        3925868416U, 3934256512U, 3942645376U, 3951032192U, 3959422336U,
+        3967809152U, 3976200064U, 3984588416U, 3992974976U, 4001363584U,
+        4009751168U, 4018141312U, 4026530432U, 4034911616U, 4043308928U,
+        4051695488U, 4060084352U, 4068472448U, 4076862848U, 4085249408U,
+        4093640576U, 4102028416U, 4110413696U, 4118805632U, 4127194496U,
+        4135583104U, 4143971968U, 4152360832U, 4160746112U, 4169135744U,
+        4177525888U, 4185912704U, 4194303616U, 4202691968U, 4211076736U,
+        4219463552U, 4227855488U, 4236246656U, 4244633728U, 4253022848U,
+        4261412224U, 4269799808U, 4278184832U, 4286578048U, 4294962304U,
+        4303349632U, 4311743104U, 4320130432U, 4328521088U, 4336909184U,
+        4345295488U, 4353687424U, 4362073472U, 4370458496U, 4378852736U,
+        4387238528U, 4395630208U, 4404019072U, 4412407424U, 4420790656U,
+        4429182848U, 4437571456U, 4445962112U, 4454344064U, 4462738048U,
+        4471119232U, 4479516544U, 4487904128U, 4496289664U, 4504682368U,
+        4513068416U, 4521459584U, 4529846144U, 4538232704U, 4546619776U,
+        4555010176U, 4563402112U, 4571790208U, 4580174464U, 4588567936U,
+        4596957056U, 4605344896U, 4613734016U, 4622119808U, 4630511488U,
+        4638898816U, 4647287936U, 4655675264U, 4664065664U, 4672451968U,
+        4680842624U, 4689231488U, 4697620352U, 4706007424U, 4714397056U,
+        4722786176U, 4731173248U, 4739562368U, 4747951744U, 4756340608U,
+        4764727936U, 4773114496U, 4781504384U, 4789894784U, 4798283648U,
+        4806667648U, 4815059584U, 4823449472U, 4831835776U, 4840226176U,
+        4848612224U, 4857003392U, 4865391488U, 4873780096U, 4882169728U,
+        4890557312U, 4898946944U, 4907333248U, 4915722368U, 4924110976U,
+        4932499328U, 4940889728U, 4949276032U, 4957666432U, 4966054784U,
+        4974438016U, 4982831488U, 4991221376U, 4999607168U, 5007998848U,
+        5016386432U, 5024763776U, 5033164672U, 5041544576U, 5049941888U,
+        5058329728U, 5066717056U, 5075107456U, 5083494272U, 5091883904U,
+        5100273536U, 5108662144U, 5117048192U, 5125436032U, 5133827456U,
+        5142215296U, 5150605184U, 5158993024U, 5167382144U, 5175769472U,
+        5184157568U, 5192543872U, 5200936064U, 5209324928U, 5217711232U,
+        5226102656U, 5234490496U, 5242877312U, 5251263872U, 5259654016U,
+        5268040832U, 5276434304U, 5284819328U, 5293209728U, 5301598592U,
+        5309986688U, 5318374784U, 5326764416U, 5335151488U, 5343542144U,
+        5351929472U, 5360319872U, 5368706944U, 5377096576U, 5385484928U,
+        5393871232U, 5402263424U, 5410650496U, 5419040384U, 5427426944U,
+        5435816576U, 5444205952U, 5452594816U, 5460981376U, 5469367936U,
+        5477760896U, 5486148736U, 5494536832U, 5502925952U, 5511315328U,
+        5519703424U, 5528089984U, 5536481152U, 5544869504U, 5553256064U,
+        5561645696U, 5570032768U, 5578423936U, 5586811264U, 5595193216U,
+        5603585408U, 5611972736U, 5620366208U, 5628750464U, 5637143936U,
+        5645528192U, 5653921408U, 5662310272U, 5670694784U, 5679082624U,
+        5687474048U, 5695864448U, 5704251008U, 5712641408U, 5721030272U,
+        5729416832U, 5737806208U, 5746194304U, 5754583936U, 5762969984U,
+        5771358592U, 5779748224U, 5788137856U, 5796527488U, 5804911232U,
+        5813300608U, 5821692544U, 5830082176U, 5838468992U, 5846855552U,
+        5855247488U, 5863636096U, 5872024448U, 5880411008U, 5888799872U,
+        5897186432U, 5905576832U, 5913966976U, 5922352768U, 5930744704U,
+        5939132288U, 5947522432U, 5955911296U, 5964299392U, 5972688256U,
+        5981074304U, 5989465472U, 5997851008U, 6006241408U, 6014627968U,
+        6023015552U, 6031408256U, 6039796096U, 6048185216U, 6056574848U,
+        6064963456U, 6073351808U, 6081736064U, 6090128768U, 6098517632U,
+        6106906496U, 6115289216U, 6123680896U, 6132070016U, 6140459648U,
+        6148849024U, 6157237376U, 6165624704U, 6174009728U, 6182403712U,
+        6190792064U, 6199176064U, 6207569792U, 6215952256U, 6224345216U,
+        6232732544U, 6241124224U, 6249510272U, 6257899136U, 6266287744U,
+        6274676864U, 6283065728U, 6291454336U, 6299843456U, 6308232064U,
+        6316620928U, 6325006208U, 6333395584U, 6341784704U, 6350174848U,
+        6358562176U, 6366951296U, 6375337856U, 6383729536U, 6392119168U,
+        6400504192U, 6408895616U, 6417283456U, 6425673344U, 6434059136U,
+        6442444672U, 6450837376U, 6459223424U, 6467613056U, 6476004224U,
+        6484393088U, 6492781952U, 6501170048U, 6509555072U, 6517947008U,
+        6526336384U, 6534725504U, 6543112832U, 6551500672U, 6559888768U,
+        6568278656U, 6576662912U, 6585055616U, 6593443456U, 6601834112U,
+        6610219648U, 6618610304U, 6626999168U, 6635385472U, 6643777408U,
+        6652164224U, 6660552832U, 6668941952U, 6677330048U, 6685719424U,
+        6694107776U, 6702493568U, 6710882176U, 6719274112U, 6727662976U,
+        6736052096U, 6744437632U, 6752825984U, 6761213824U, 6769604224U,
+        6777993856U, 6786383488U, 6794770816U, 6803158144U, 6811549312U,
+        6819937664U, 6828326528U, 6836706176U, 6845101696U, 6853491328U,
+        6861880448U, 6870269312U, 6878655104U, 6887046272U, 6895433344U,
+        6903822208U, 6912212864U, 6920596864U, 6928988288U, 6937377152U,
+        6945764992U, 6954149248U, 6962544256U, 6970928768U, 6979317376U,
+        6987709312U, 6996093824U, 7004487296U, 7012875392U, 7021258624U,
+        7029652352U, 7038038912U, 7046427776U, 7054818944U, 7063207808U,
+        7071595136U, 7079980928U, 7088372608U, 7096759424U, 7105149824U,
+        7113536896U, 7121928064U, 7130315392U, 7138699648U, 7147092352U,
+        7155479168U, 7163865728U, 7172249984U, 7180648064U, 7189036672U,
+        7197424768U, 7205810816U, 7214196608U, 7222589824U, 7230975104U,
+        7239367552U, 7247755904U, 7256145536U, 7264533376U, 7272921472U,
+        7281308032U, 7289694848U, 7298088832U, 7306471808U, 7314864512U,
+        7323253888U, 7331643008U, 7340029568U, 7348419712U, 7356808832U,
+        7365196672U, 7373585792U, 7381973888U, 7390362752U, 7398750592U,
+        7407138944U, 7415528576U, 7423915648U, 7432302208U, 7440690304U,
+        7449080192U, 7457472128U, 7465860992U, 7474249088U, 7482635648U,
+        7491023744U, 7499412608U, 7507803008U, 7516192384U, 7524579968U,
+        7532967296U, 7541358464U, 7549745792U, 7558134656U, 7566524032U,
+        7574912896U, 7583300992U, 7591690112U, 7600075136U, 7608466816U,
+        7616854912U, 7625244544U, 7633629824U, 7642020992U, 7650410368U,
+        7658794112U, 7667187328U, 7675574912U, 7683961984U, 7692349568U,
+        7700739712U, 7709130368U, 7717519232U, 7725905536U, 7734295424U,
+        7742683264U, 7751069056U, 7759457408U, 7767849088U, 7776238208U,
+        7784626816U, 7793014912U, 7801405312U, 7809792128U, 7818179968U,
+        7826571136U, 7834957184U, 7843347328U, 7851732352U, 7860124544U,
+        7868512384U, 7876902016U, 7885287808U, 7893679744U, 7902067072U,
+        7910455936U, 7918844288U, 7927230848U, 7935622784U, 7944009344U,
+        7952400256U, 7960786048U, 7969176704U, 7977565312U, 7985953408U,
+        7994339968U, 8002730368U, 8011119488U, 8019508096U, 8027896192U,
+        8036285056U, 8044674688U, 8053062272U, 8061448832U, 8069838464U,
+        8078227328U, 8086616704U, 8095006592U, 8103393664U, 8111783552U,
+        8120171392U, 8128560256U, 8136949376U, 8145336704U, 8153726848U,
+        8162114944U, 8170503296U, 8178891904U, 8187280768U, 8195669632U,
+        8204058496U, 8212444544U, 8220834176U, 8229222272U, 8237612672U,
+        8246000768U, 8254389376U, 8262775168U, 8271167104U, 8279553664U,
+        8287944064U, 8296333184U, 8304715136U, 8313108352U, 8321497984U,
+        8329885568U, 8338274432U, 8346663296U, 8355052928U, 8363441536U,
+        8371828352U, 8380217984U, 8388606592U, 8396996224U, 8405384576U,
+        8413772672U, 8422161536U, 8430549376U, 8438939008U, 8447326592U,
+        8455715456U, 8464104832U, 8472492928U, 8480882048U, 8489270656U,
+        8497659776U, 8506045312U, 8514434944U, 8522823808U, 8531208832U,
+        8539602304U, 8547990656U, 8556378752U, 8564768384U, 8573154176U,
+        8581542784U, 8589933952U, 8598322816U, 8606705024U, 8615099264U,
+        8623487872U, 8631876992U, 8640264064U, 8648653952U, 8657040256U,
+        8665430656U, 8673820544U, 8682209152U, 8690592128U, 8698977152U,
+        8707374464U, 8715763328U, 8724151424U, 8732540032U, 8740928384U,
+        8749315712U, 8757704576U, 8766089344U, 8774480768U, 8782871936U,
+        8791260032U, 8799645824U, 8808034432U, 8816426368U, 8824812928U,
+        8833199488U, 8841591424U, 8849976448U, 8858366336U, 8866757248U,
+        8875147136U, 8883532928U, 8891923328U, 8900306816U, 8908700288U,
+        8917088384U, 8925478784U, 8933867392U, 8942250368U, 8950644608U,
+        8959032704U, 8967420544U, 8975809664U, 8984197504U, 8992584064U,
+        9000976256U, 9009362048U, 9017752448U, 9026141312U, 9034530688U,
+        9042917504U, 9051307904U, 9059694208U, 9068084864U, 9076471424U,
+        9084861824U, 9093250688U, 9101638528U, 9110027648U, 9118416512U,
+        9126803584U, 9135188096U, 9143581312U, 9151969664U, 9160356224U,
+        9168747136U, 9177134464U, 9185525632U, 9193910144U, 9202302848U,
+        9210690688U, 9219079552U, 9227465344U, 9235854464U, 9244244864U,
+        9252633472U, 9261021824U, 9269411456U, 9277799296U, 9286188928U,
+        9294574208U, 9302965888U, 9311351936U, 9319740032U, 9328131968U,
+        9336516736U, 9344907392U, 9353296768U, 9361685888U, 9370074752U,
+        9378463616U, 9386849408U, 9395239808U, 9403629184U, 9412016512U,
+        9420405376U, 9428795008U, 9437181568U, 9445570688U, 9453960832U,
+        9462346624U, 9470738048U, 9479121536U, 9487515008U, 9495903616U,
+        9504289664U, 9512678528U, 9521067904U, 9529456256U, 9537843584U,
+        9546233728U, 9554621312U, 9563011456U, 9571398784U, 9579788672U,
+        9588178304U, 9596567168U, 9604954496U, 9613343104U, 9621732992U,
+        9630121856U, 9638508416U, 9646898816U, 9655283584U, 9663675776U,
+        9672061312U, 9680449664U, 9688840064U, 9697230464U, 9705617536U,
+        9714003584U, 9722393984U, 9730772608U, 9739172224U, 9747561088U,
+        9755945344U, 9764338816U, 9772726144U, 9781116544U, 9789503872U,
+        9797892992U, 9806282624U, 9814670464U, 9823056512U, 9831439232U,
+        9839833984U, 9848224384U, 9856613504U, 9865000576U, 9873391232U,
+        9881772416U, 9890162816U, 9898556288U, 9906940544U, 9915333248U,
+        9923721088U, 9932108672U, 9940496512U, 9948888448U, 9957276544U,
+        9965666176U, 9974048384U, 9982441088U, 9990830464U, 9999219584U,
+        10007602816U, 10015996544U, 10024385152U, 10032774016U, 10041163648U,
+        10049548928U, 10057940096U, 10066329472U, 10074717824U, 10083105152U,
+        10091495296U, 10099878784U, 10108272256U, 10116660608U, 10125049216U,
+        10133437312U, 10141825664U, 10150213504U, 10158601088U, 10166991232U,
+        10175378816U, 10183766144U, 10192157312U, 10200545408U, 10208935552U,
+        10217322112U, 10225712768U, 10234099328U, 10242489472U, 10250876032U,
+        10259264896U, 10267656064U, 10276042624U, 10284429184U, 10292820352U,
+        10301209472U, 10309598848U, 10317987712U, 10326375296U, 10334763392U,
+        10343153536U, 10351541632U, 10359930752U, 10368318592U, 10376707456U,
+        10385096576U, 10393484672U, 10401867136U, 10410262144U, 10418647424U,
+        10427039104U, 10435425664U, 10443810176U, 10452203648U, 10460589952U,
+        10468982144U, 10477369472U, 10485759104U, 10494147712U, 10502533504U,
+        10510923392U, 10519313536U, 10527702656U, 10536091264U, 10544478592U,
+        10552867712U, 10561255808U, 10569642368U, 10578032768U, 10586423168U,
+        10594805632U, 10603200128U, 10611588992U, 10619976064U, 10628361344U,
+        10636754048U, 10645143424U, 10653531776U, 10661920384U, 10670307968U,
+        10678696832U, 10687086464U, 10695475072U, 10703863168U, 10712246144U,
+        10720639616U, 10729026688U, 10737414784U, 10745806208U, 10754190976U,
+        10762581376U, 10770971264U, 10779356288U, 10787747456U, 10796135552U,
+        10804525184U, 10812915584U, 10821301888U, 10829692288U, 10838078336U,
+        10846469248U, 10854858368U, 10863247232U, 10871631488U, 10880023424U,
+        10888412032U, 10896799616U, 10905188992U, 10913574016U, 10921964672U,
+        10930352768U, 10938742912U, 10947132544U, 10955518592U, 10963909504U,
+        10972298368U, 10980687488U, 10989074816U, 10997462912U, 11005851776U,
+        11014241152U, 11022627712U, 11031017344U, 11039403904U, 11047793024U,
+        11056184704U, 11064570752U, 11072960896U, 11081343872U, 11089737856U,
+        11098128256U, 11106514816U, 11114904448U, 11123293568U, 11131680128U,
+        11140065152U, 11148458368U, 11156845696U, 11165236864U, 11173624192U,
+        11182013824U, 11190402688U, 11198790784U, 11207179136U, 11215568768U,
+        11223957376U, 11232345728U, 11240734592U, 11249122688U, 11257511296U,
+        11265899648U, 11274285952U, 11282675584U, 11291065472U, 11299452544U,
+        11307842432U, 11316231296U, 11324616832U, 11333009024U, 11341395584U,
+        11349782656U, 11358172288U, 11366560384U, 11374950016U, 11383339648U,
+        11391721856U, 11400117376U, 11408504192U, 11416893568U, 11425283456U,
+        11433671552U, 11442061184U, 11450444672U, 11458837888U, 11467226752U,
+        11475611776U, 11484003968U, 11492392064U, 11500780672U, 11509169024U,
+        11517550976U, 11525944448U, 11534335616U, 11542724224U, 11551111808U,
+        11559500672U, 11567890304U, 11576277376U, 11584667008U, 11593056128U,
+        11601443456U, 11609830016U, 11618221952U, 11626607488U, 11634995072U,
+        11643387776U, 11651775104U, 11660161664U, 11668552576U, 11676940928U,
+        11685330304U, 11693718656U, 11702106496U, 11710496128U, 11718882688U,
+        11727273088U, 11735660416U, 11744050048U, 11752437376U, 11760824704U,
+        11769216128U, 11777604736U, 11785991296U, 11794381952U, 11802770048U,
+        11811157888U, 11819548544U, 11827932544U, 11836324736U, 11844713344U,
+        11853100928U, 11861486464U, 11869879936U, 11878268032U, 11886656896U,
+        11895044992U, 11903433088U, 11911822976U, 11920210816U, 11928600448U,
+        11936987264U, 11945375872U, 11953761152U, 11962151296U, 11970543488U,
+        11978928512U, 11987320448U, 11995708288U, 12004095104U, 12012486272U,
+        12020875136U, 12029255552U, 12037652096U, 12046039168U, 12054429568U,
+        12062813824U, 12071206528U, 12079594624U, 12087983744U, 12096371072U,
+        12104759936U, 12113147264U, 12121534592U, 12129924992U, 12138314624U,
+        12146703232U, 12155091584U, 12163481216U, 12171864704U, 12180255872U,
+        12188643968U, 12197034112U, 12205424512U, 12213811328U, 12222199424U,
+        12230590336U, 12238977664U, 12247365248U, 12255755392U, 12264143488U,
+        12272531584U, 12280920448U, 12289309568U, 12297694592U, 12306086528U,
+        12314475392U, 12322865024U, 12331253632U, 12339640448U, 12348029312U,
+        12356418944U, 12364805248U, 12373196672U, 12381580928U, 12389969024U,
+        12398357632U, 12406750592U, 12415138432U, 12423527552U, 12431916416U,
+        12440304512U, 12448692352U, 12457081216U, 12465467776U, 12473859968U,
+        12482245504U, 12490636672U, 12499025536U, 12507411584U, 12515801728U,
+        12524190592U, 12532577152U, 12540966272U, 12549354368U, 12557743232U,
+        12566129536U, 12574523264U, 12582911872U, 12591299456U, 12599688064U,
+        12608074624U, 12616463488U, 12624845696U, 12633239936U, 12641631616U,
+        12650019968U, 12658407296U, 12666795136U, 12675183232U, 12683574656U,
+        12691960192U, 12700350592U, 12708740224U, 12717128576U, 12725515904U,
+        12733906816U, 12742295168U, 12750680192U, 12759071872U, 12767460736U,
+        12775848832U, 12784236928U, 12792626816U, 12801014656U, 12809404288U,
+        12817789312U, 12826181504U, 12834568832U, 12842954624U, 12851345792U,
+        12859732352U, 12868122496U, 12876512128U, 12884901248U, 12893289088U,
+        12901672832U, 12910067584U, 12918455168U, 12926842496U, 12935232896U,
+        12943620736U, 12952009856U, 12960396928U, 12968786816U, 12977176192U,
+        12985563776U, 12993951104U, 13002341504U, 13010730368U, 13019115392U,
+        13027506304U, 13035895168U, 13044272512U, 13052673152U, 13061062528U,
+        13069446272U, 13077838976U, 13086227072U, 13094613632U, 13103000192U,
+        13111393664U, 13119782528U, 13128157568U, 13136559232U, 13144945024U,
+        13153329536U, 13161724288U, 13170111872U, 13178502784U, 13186884736U,
+        13195279744U, 13203667072U, 13212057472U, 13220445824U, 13228832128U,
+        13237221248U, 13245610624U, 13254000512U, 13262388352U, 13270777472U,
+        13279166336U, 13287553408U, 13295943296U, 13304331904U, 13312719488U,
+        13321108096U, 13329494656U, 13337885824U, 13346274944U, 13354663808U,
+        13363051136U, 13371439232U, 13379825024U, 13388210816U, 13396605056U,
+        13404995456U, 13413380224U, 13421771392U, 13430159744U, 13438546048U,
+        13446937216U, 13455326848U, 13463708288U, 13472103808U, 13480492672U,
+        13488875648U, 13497269888U, 13505657728U, 13514045312U, 13522435712U,
+        13530824576U, 13539210112U, 13547599232U, 13555989376U, 13564379008U,
+        13572766336U, 13581154432U, 13589544832U, 13597932928U, 13606320512U,
+        13614710656U, 13623097472U, 13631477632U, 13639874944U, 13648264064U,
+        13656652928U, 13665041792U, 13673430656U, 13681818496U, 13690207616U,
+        13698595712U, 13706982272U, 13715373184U, 13723762048U, 13732150144U,
+        13740536704U, 13748926592U, 13757316224U, 13765700992U, 13774090112U,
+        13782477952U, 13790869376U, 13799259008U, 13807647872U, 13816036736U,
+        13824425344U, 13832814208U, 13841202304U, 13849591424U, 13857978752U,
+        13866368896U, 13874754688U, 13883145344U, 13891533184U, 13899919232U,
+        13908311168U, 13916692096U, 13925085056U, 13933473152U, 13941866368U,
+        13950253696U, 13958643584U, 13967032192U, 13975417216U, 13983807616U,
+        13992197504U, 14000582272U, 14008973696U, 14017363072U, 14025752192U,
+        14034137984U, 14042528384U, 14050918016U, 14059301504U, 14067691648U,
+        14076083584U, 14084470144U, 14092852352U, 14101249664U, 14109635968U,
+        14118024832U, 14126407552U, 14134804352U, 14143188608U, 14151577984U,
+        14159968384U, 14168357248U, 14176741504U, 14185127296U, 14193521024U,
+        14201911424U, 14210301824U, 14218685056U, 14227067264U, 14235467392U,
+        14243855488U, 14252243072U, 14260630144U, 14269021568U, 14277409408U,
+        14285799296U, 14294187904U, 14302571392U, 14310961792U, 14319353728U,
+        14327738752U, 14336130944U, 14344518784U, 14352906368U, 14361296512U,
+        14369685376U, 14378071424U, 14386462592U, 14394848128U, 14403230848U,
+        14411627392U, 14420013952U, 14428402304U, 14436793472U, 14445181568U,
+        14453569664U, 14461959808U, 14470347904U, 14478737024U, 14487122816U,
+        14495511424U, 14503901824U, 14512291712U, 14520677504U, 14529064832U,
+        14537456768U, 14545845632U, 14554234496U, 14562618496U, 14571011456U,
+        14579398784U, 14587789184U, 14596172672U, 14604564608U, 14612953984U,
+        14621341312U, 14629724288U, 14638120832U, 14646503296U, 14654897536U,
+        14663284864U, 14671675264U, 14680061056U, 14688447616U, 14696835968U,
+        14705228416U, 14713616768U, 14722003328U, 14730392192U, 14738784128U,
+        14747172736U, 14755561088U, 14763947648U, 14772336512U, 14780725376U,
+        14789110144U, 14797499776U, 14805892736U, 14814276992U, 14822670208U,
+        14831056256U, 14839444352U, 14847836032U, 14856222848U, 14864612992U,
+        14872997504U, 14881388672U, 14889775744U, 14898165376U, 14906553472U,
+        14914944896U, 14923329664U, 14931721856U, 14940109696U, 14948497024U,
+        14956887424U, 14965276544U, 14973663616U, 14982053248U, 14990439808U,
+        14998830976U, 15007216768U, 15015605888U, 15023995264U, 15032385152U,
+        15040768384U, 15049154944U, 15057549184U, 15065939072U, 15074328448U,
+        15082715008U, 15091104128U, 15099493504U, 15107879296U, 15116269184U,
+        15124659584U, 15133042304U, 15141431936U, 15149824384U, 15158214272U,
+        15166602368U, 15174991232U, 15183378304U, 15191760512U, 15200154496U,
+        15208542592U, 15216931712U, 15225323392U, 15233708416U, 15242098048U,
+        15250489216U, 15258875264U, 15267265408U, 15275654528U, 15284043136U,
+        15292431488U, 15300819584U, 15309208192U, 15317596544U, 15325986176U,
+        15334374784U, 15342763648U, 15351151744U, 15359540608U, 15367929728U,
+        15376318336U, 15384706432U, 15393092992U, 15401481856U, 15409869952U,
+        15418258816U, 15426649984U, 15435037568U, 15443425664U, 15451815296U,
+        15460203392U, 15468589184U, 15476979328U, 15485369216U, 15493755776U,
+        15502146944U, 15510534272U, 15518924416U, 15527311232U, 15535699072U,
+        15544089472U, 15552478336U, 15560866688U, 15569254528U, 15577642624U,
+        15586031488U, 15594419072U, 15602809472U, 15611199104U, 15619586432U,
+        15627975296U, 15636364928U, 15644753792U, 15653141888U, 15661529216U,
+        15669918848U, 15678305152U, 15686696576U, 15695083136U, 15703474048U,
+        15711861632U, 15720251264U, 15728636288U, 15737027456U, 15745417088U,
+        15753804928U, 15762194048U, 15770582656U, 15778971008U, 15787358336U,
+        15795747712U, 15804132224U, 15812523392U, 15820909696U, 15829300096U,
+        15837691264U, 15846071936U, 15854466944U, 15862855808U, 15871244672U,
+        15879634816U, 15888020608U, 15896409728U, 15904799104U, 15913185152U,
+        15921577088U, 15929966464U, 15938354816U, 15946743424U, 15955129472U,
+        15963519872U, 15971907968U, 15980296064U, 15988684928U, 15997073024U,
+        16005460864U, 16013851264U, 16022241152U, 16030629248U, 16039012736U,
+        16047406976U, 16055794816U, 16064181376U, 16072571264U, 16080957824U,
+        16089346688U, 16097737856U, 16106125184U, 16114514816U, 16122904192U,
+        16131292544U, 16139678848U, 16148066944U, 16156453504U, 16164839552U,
+        16173236096U, 16181623424U, 16190012032U, 16198401152U, 16206790528U,
+        16215177344U, 16223567744U, 16231956352U, 16240344704U, 16248731008U,
+        16257117824U, 16265504384U, 16273898624U, 16282281856U, 16290668672U,
+        16299064192U, 16307449216U, 16315842176U, 16324230016U, 16332613504U,
+        16341006464U, 16349394304U, 16357783168U, 16366172288U, 16374561664U,
+        16382951296U, 16391337856U, 16399726208U, 16408116352U, 16416505472U,
+        16424892032U, 16433282176U, 16441668224U, 16450058624U, 16458448768U,
+        16466836864U, 16475224448U, 16483613056U, 16492001408U, 16500391808U,
+        16508779648U, 16517166976U, 16525555328U, 16533944192U, 16542330752U,
+        16550719616U, 16559110528U, 16567497088U, 16575888512U, 16584274816U,
+        16592665472U, 16601051008U, 16609442944U, 16617832064U, 16626218624U,
+        16634607488U, 16642996096U, 16651385728U, 16659773824U, 16668163712U,
+        16676552576U, 16684938112U, 16693328768U, 16701718144U, 16710095488U,
+        16718492288U, 16726883968U, 16735272832U, 16743661184U, 16752049792U,
+        16760436608U, 16768827008U, 16777214336U, 16785599104U, 16793992832U,
+        16802381696U, 16810768768U, 16819151744U, 16827542656U, 16835934848U,
+        16844323712U, 16852711552U, 16861101952U, 16869489536U, 16877876864U,
+        16886265728U, 16894653056U, 16903044736U, 16911431296U, 16919821696U,
+        16928207488U, 16936592768U, 16944987776U, 16953375616U, 16961763968U,
+        16970152832U, 16978540928U, 16986929536U, 16995319168U, 17003704448U,
+        17012096896U, 17020481152U, 17028870784U, 17037262208U, 17045649536U,
+        17054039936U, 17062426496U, 17070814336U, 17079205504U, 17087592064U,
+        17095978112U, 17104369024U, 17112759424U, 17121147776U, 17129536384U,
+        17137926016U, 17146314368U, 17154700928U, 17163089792U, 17171480192U,
+        17179864192U, 17188256896U, 17196644992U, 17205033856U, 17213423488U,
+        17221811072U, 17230198912U, 17238588032U, 17246976896U, 17255360384U,
+        17263754624U, 17272143232U, 17280530048U, 17288918912U, 17297309312U,
+        17305696384U, 17314085504U, 17322475136U, 17330863744U, 17339252096U,
+        17347640192U, 17356026496U, 17364413824U, 17372796544U, 17381190016U,
+        17389583488U, 17397972608U, 17406360704U, 17414748544U, 17423135872U,
+        17431527296U, 17439915904U, 17448303232U, 17456691584U, 17465081728U,
+        17473468288U, 17481857408U, 17490247552U, 17498635904U, 17507022464U,
+        17515409024U, 17523801728U, 17532189824U, 17540577664U, 17548966016U,
+        17557353344U, 17565741184U, 17574131584U, 17582519168U, 17590907008U,
+        17599296128U, 17607687808U, 17616076672U, 17624455808U, 17632852352U,
+        17641238656U, 17649630848U, 17658018944U, 17666403968U, 17674794112U,
+        17683178368U, 17691573376U, 17699962496U, 17708350592U, 17716739968U,
+        17725126528U, 17733517184U, 17741898112U, 17750293888U, 17758673024U,
+        17767070336U, 17775458432U, 17783848832U, 17792236928U, 17800625536U,
+        17809012352U, 17817402752U, 17825785984U, 17834178944U, 17842563968U,
+        17850955648U, 17859344512U, 17867732864U, 17876119424U, 17884511872U,
+        17892900224U, 17901287296U, 17909677696U, 17918058112U, 17926451072U,
+        17934843776U, 17943230848U, 17951609216U, 17960008576U, 17968397696U,
+        17976784256U, 17985175424U, 17993564032U, 18001952128U, 18010339712U,
+        18018728576U, 18027116672U, 18035503232U, 18043894144U, 18052283264U,
+        18060672128U, 18069056384U, 18077449856U, 18085837184U, 18094225792U,
+        18102613376U, 18111004544U, 18119388544U, 18127781248U, 18136170368U,
+        18144558976U, 18152947328U, 18161336192U, 18169724288U, 18178108544U,
+        18186498944U, 18194886784U, 18203275648U, 18211666048U, 18220048768U,
+        18228444544U, 18236833408U, 18245220736U
+};
+
+
+// Generated with the following Mathematica Code:
+
+// GetCacheSizes[n_] := Module[{
+//         DataSetSizeBytesInit = 2^30,
+//         MixBytes = 128,
+//         DataSetGrowth = 2^23,
+//         HashBytes = 64,
+//         CacheMultiplier = 1024,
+//         j = 0},
+//     Reap[
+//       While[j < n,
+//        Module[{i = Floor[(DataSetSizeBytesInit + DataSetGrowth * j) / (CacheMultiplier * HashBytes)]},
+//         While[! PrimeQ[i], i--];
+//         Sow[i*HashBytes]; j++]]]][[2]][[1]]
+
+const size_t cache_sizes[] = {
+        1048384U, 1055552U, 1064512U, 1072832U, 1080896U, 1089344U, 1096768U,
+        1104448U, 1113664U, 1121216U, 1130176U, 1138624U, 1146304U, 1155008U,
+        1162816U, 1171264U, 1179328U, 1187392U, 1195456U, 1203392U, 1210816U,
+        1220416U, 1227712U, 1236416U, 1244608U, 1253312U, 1261376U, 1268416U,
+        1277632U, 1285696U, 1294016U, 1302208U, 1310656U, 1318336U, 1326784U,
+        1334848U, 1342912U, 1350848U, 1359808U, 1366208U, 1376192U, 1383488U,
+        1392448U, 1400384U, 1408832U, 1416512U, 1425344U, 1433408U, 1440704U,
+        1449664U, 1458112U, 1466048U, 1474496U, 1482688U, 1490752U, 1498688U,
+        1507136U, 1515328U, 1523264U, 1531456U, 1539904U, 1547584U, 1556288U,
+        1564352U, 1572544U, 1580608U, 1588544U, 1596992U, 1605568U, 1612096U,
+        1621952U, 1630144U, 1637696U, 1645888U, 1654336U, 1662784U, 1671104U,
+        1679168U, 1686848U, 1695296U, 1702208U, 1711168U, 1720256U, 1727552U,
+        1736128U, 1744576U, 1751488U, 1760576U, 1769408U, 1777472U, 1785664U,
+        1793984U, 1801664U, 1810112U, 1818304U, 1826624U, 1834816U, 1842752U,
+        1851328U, 1858112U, 1867456U, 1875904U, 1883968U, 1892288U, 1899712U,
+        1908416U, 1916608U, 1924544U, 1932992U, 1940672U, 1948736U, 1956928U,
+        1965632U, 1973824U, 1982144U, 1989824U, 1998784U, 2006848U, 2014784U,
+        2022848U, 2031424U, 2038976U, 2047424U, 2055616U, 2064064U, 2072384U,
+        2080448U, 2088512U, 2095936U, 2104768U, 2113472U, 2121664U, 2127808U,
+        2137792U, 2146112U, 2153408U, 2162624U, 2170304U, 2178496U, 2186944U,
+        2195392U, 2203456U, 2211136U, 2219968U, 2227648U, 2236096U, 2244416U,
+        2250944U, 2260928U, 2268736U, 2276672U, 2283328U, 2293696U, 2301632U,
+        2309312U, 2317888U, 2325952U, 2334656U, 2342848U, 2350144U, 2358848U,
+        2366656U, 2375488U, 2383552U, 2391616U, 2400064U, 2407616U, 2415808U,
+        2424256U, 2432704U, 2439616U, 2448704U, 2457152U, 2464064U, 2473792U,
+        2482112U, 2489792U, 2497472U, 2506432U, 2514752U, 2522816U, 2531264U,
+        2539456U, 2547136U, 2555456U, 2564032U, 2572096U, 2578496U, 2587712U,
+        2595776U, 2604736U, 2613056U, 2620736U, 2629184U, 2637632U, 2645824U,
+        2653888U, 2662208U, 2670016U, 2678464U, 2686912U, 2694464U, 2703296U,
+        2710976U, 2719424U, 2727104U, 2736064U, 2743232U, 2752192U, 2760512U,
+        2768704U, 2777024U, 2785088U, 2792512U, 2800576U, 2809024U, 2817856U,
+        2826176U, 2833984U, 2840896U, 2850752U, 2858048U, 2867008U, 2875328U,
+        2883392U, 2891584U, 2899648U, 2908096U, 2915648U, 2924224U, 2932672U,
+        2940736U, 2948672U, 2956736U, 2964928U, 2973248U, 2981824U, 2988992U,
+        2997184U, 3005248U, 3013952U, 3022144U, 3030592U, 3037376U, 3046976U,
+        3055552U, 3063616U, 3070784U, 3079744U, 3087808U, 3096512U, 3103808U,
+        3111872U, 3121088U, 3128896U, 3137216U, 3144896U, 3153856U, 3161152U,
+        3169984U, 3178432U, 3186496U, 3194816U, 3203008U, 3210176U, 3218624U,
+        3227072U, 3235264U, 3243712U, 3250496U, 3259456U, 3268544U, 3276736U,
+        3283648U, 3292736U, 3301184U, 3308224U, 3317696U, 3324736U, 3333184U,
+        3342272U, 3348544U, 3357248U, 3365312U, 3374912U, 3383104U, 3390784U,
+        3399488U, 3407296U, 3414976U, 3424192U, 3432256U, 3440576U, 3448768U,
+        3456832U, 3464896U, 3473216U, 3480128U, 3489344U, 3497408U, 3505856U,
+        3514048U, 3521344U, 3530432U, 3538624U, 3546304U, 3555008U, 3563072U,
+        3571648U, 3579712U, 3587392U, 3595456U, 3603904U, 3612352U, 3620416U,
+        3628864U, 3636928U, 3645248U, 3652928U, 3660992U, 3669184U, 3677888U,
+        3685952U, 3694528U, 3702592U, 3710528U, 3719104U, 3727168U, 3735488U,
+        3742784U, 3751232U, 3759424U, 3765184U, 3775808U, 3783872U, 3792832U,
+        3800768U, 3808832U, 3816256U, 3825344U, 3832768U, 3841856U, 3849536U,
+        3857344U, 3866432U, 3874496U, 3882304U, 3890752U, 3899072U, 3907264U,
+        3914816U, 3923008U, 3930688U, 3939904U, 3947968U, 3956416U, 3964736U,
+        3972544U, 3981248U, 3988928U, 3997376U, 4005824U, 4012864U, 4020928U,
+        4030144U, 4038592U, 4045504U, 4054592U, 4063168U, 4071104U, 4079552U,
+        4087232U, 4095808U, 4103872U, 4111168U, 4120384U, 4127936U, 4136512U,
+        4144832U, 4153024U, 4160704U, 4169408U, 4177216U, 4186048U, 4193344U,
+        4202048U, 4210496U, 4217536U, 4227008U, 4235072U, 4243264U, 4251584U,
+        4259392U, 4267712U, 4275776U, 4284352U, 4291904U, 4300096U, 4307648U,
+        4316992U, 4325056U, 4333376U, 4341056U, 4349888U, 4357568U, 4366016U,
+        4374464U, 4382528U, 4390208U, 4398656U, 4407232U, 4413632U, 4423616U,
+        4431808U, 4439744U, 4447936U, 4455872U, 4463296U, 4472128U, 4480576U,
+        4489024U, 4497344U, 4505152U, 4512448U, 4520896U, 4530112U, 4537664U,
+        4546496U, 4554688U, 4562752U, 4570816U, 4579264U, 4586944U, 4595648U,
+        4603712U, 4611392U, 4619072U, 4628032U, 4635584U, 4643776U, 4652864U,
+        4660672U, 4669376U, 4677056U, 4684096U, 4693184U, 4702144U, 4710208U,
+        4718528U, 4726336U, 4734272U, 4742464U, 4750784U, 4759232U, 4767296U,
+        4775872U, 4783808U, 4791872U, 4797376U, 4808512U, 4816192U, 4825024U,
+        4832704U, 4841024U, 4849472U, 4856512U, 4865984U, 4874176U, 4882112U,
+        4889792U, 4898752U, 4906688U, 4913984U, 4922816U, 4931008U, 4938944U,
+        4946624U, 4955584U, 4964032U, 4972096U, 4980032U, 4988864U, 4997056U,
+        5004992U, 5012288U, 5020096U, 5029312U, 5037632U, 5045696U, 5052224U,
+        5062592U, 5070784U, 5078848U, 5086784U, 5095232U, 5100736U, 5111488U,
+        5119936U, 5127104U, 5136064U, 5143616U, 5151424U, 5160256U, 5168704U,
+        5175232U, 5185472U, 5192384U, 5199296U, 5209664U, 5218112U, 5225536U,
+        5233472U, 5242816U, 5250496U, 5258944U, 5267264U, 5274944U, 5283776U,
+        5290048U, 5300032U, 5308096U, 5316544U, 5323328U, 5331904U, 5340736U,
+        5349056U, 5356864U, 5365312U, 5372096U, 5381696U, 5390272U, 5398336U,
+        5405888U, 5413696U, 5422784U, 5430976U, 5439424U, 5446976U, 5455808U,
+        5463616U, 5471168U, 5480128U, 5488064U, 5494592U, 5504704U, 5513152U,
+        5521216U, 5529536U, 5536576U, 5544256U, 5554112U, 5559616U, 5570368U,
+        5577664U, 5586752U, 5594944U, 5603008U, 5611456U, 5619392U, 5627584U,
+        5634368U, 5643328U, 5651264U, 5659328U, 5667008U, 5675584U, 5684416U,
+        5692864U, 5701568U, 5709632U, 5717056U, 5725376U, 5734336U, 5740096U,
+        5750336U, 5758912U, 5766848U, 5775296U, 5782976U, 5790784U, 5799616U,
+        5807936U, 5815232U, 5823808U, 5832256U, 5840192U, 5848768U, 5856832U,
+        5864896U, 5873344U, 5879872U, 5888576U, 5897792U, 5905216U, 5914432U,
+        5920448U, 5930944U, 5938624U, 5947328U, 5955392U, 5963456U, 5971648U,
+        5979328U, 5988032U, 5995712U, 6003904U, 6012736U, 6021056U, 6029248U,
+        6037184U, 6045632U, 6053312U, 6061376U, 6070208U, 6077504U, 6086464U,
+        6094784U, 6101696U, 6110912U, 6118592U, 6127168U, 6135616U, 6143296U,
+        6150208U, 6158912U, 6168128U, 6175808U, 6182464U, 6192832U, 6201152U,
+        6209344U, 6217664U, 6224576U, 6233408U, 6241472U, 6249664U, 6258496U,
+        6266816U, 6275008U, 6281152U, 6291136U, 6299456U, 6306752U, 6314816U,
+        6323776U, 6332096U, 6339392U, 6348224U, 6356288U, 6364096U, 6373184U,
+        6381376U, 6389696U, 6397504U, 6404416U, 6413632U, 6421952U, 6430016U,
+        6437824U, 6446912U, 6454592U, 6463168U, 6471616U, 6478144U, 6487232U,
+        6496192U, 6504128U, 6511936U, 6520256U, 6528832U, 6536896U, 6544576U,
+        6553408U, 6561472U, 6569792U, 6577216U, 6586304U, 6592448U, 6601024U,
+        6610624U, 6619072U, 6627136U, 6634816U, 6643264U, 6650816U, 6659776U,
+        6667712U, 6675904U, 6682688U, 6691904U, 6700864U, 6709184U, 6717376U,
+        6724544U, 6733504U, 6741824U, 6749888U, 6756032U, 6766528U, 6773056U,
+        6782912U, 6790976U, 6798016U, 6807488U, 6815168U, 6823744U, 6832064U,
+        6840128U, 6847552U, 6855872U, 6864064U, 6872128U, 6880576U, 6889408U,
+        6897472U, 6905792U, 6913472U, 6920896U, 6930368U, 6938432U, 6946624U,
+        6953536U, 6963136U, 6971072U, 6979136U, 6986944U, 6995392U, 7003712U,
+        7012288U, 7019072U, 7028416U, 7036352U, 7044416U, 7051712U, 7060672U,
+        7069376U, 7077568U, 7085504U, 7092544U, 7102016U, 7110592U, 7118656U,
+        7126208U, 7135168U, 7143104U, 7150912U, 7159744U, 7167808U, 7175744U,
+        7184192U, 7191232U, 7200448U, 7207744U, 7216576U, 7224128U, 7233472U,
+        7241536U, 7249856U, 7256512U, 7264832U, 7274048U, 7282112U, 7290176U,
+        7298752U, 7306688U, 7315136U, 7322816U, 7331392U, 7339456U, 7347776U,
+        7356224U, 7364288U, 7371712U, 7380928U, 7387456U, 7396544U, 7404352U,
+        7413568U, 7421632U, 7429696U, 7436864U, 7446464U, 7454144U, 7461952U,
+        7470784U, 7478336U, 7487296U, 7495616U, 7503424U, 7511872U, 7520192U,
+        7527616U, 7536448U, 7544512U, 7551424U, 7560128U, 7568576U, 7577536U,
+        7583552U, 7592512U, 7600448U, 7610048U, 7618496U, 7626176U, 7634752U,
+        7642816U, 7651264U, 7659328U, 7667008U, 7675456U, 7683136U, 7691584U,
+        7700416U, 7707584U, 7716416U, 7724224U, 7733056U, 7740608U, 7749184U,
+        7756096U, 7765952U, 7774016U, 7781824U, 7790528U, 7798592U, 7805888U,
+        7814336U, 7822784U, 7831232U, 7839296U, 7847104U, 7855552U, 7863616U,
+        7872448U, 7880128U, 7888576U, 7896256U, 7905088U, 7912768U, 7920448U,
+        7928768U, 7937344U, 7945792U, 7953728U, 7959488U, 7970752U, 7978816U,
+        7987136U, 7994816U, 8003392U, 8011712U, 8019904U, 8027456U, 8035264U,
+        8044352U, 8052544U, 8060224U, 8069056U, 8076736U, 8084672U, 8093504U,
+        8101312U, 8110016U, 8117696U, 8125888U, 8134592U, 8142016U, 8149952U,
+        8159168U, 8166976U, 8175296U, 8183488U, 8191808U, 8199616U, 8207296U,
+        8216128U, 8224576U, 8232256U, 8241088U, 8248256U, 8257472U, 8264128U,
+        8273728U, 8281792U, 8290112U, 8297152U, 8305216U, 8314816U, 8322752U,
+        8330944U, 8339392U, 8347072U, 8355392U, 8363968U, 8371904U, 8379328U,
+        8388544U, 8394944U, 8404544U, 8412736U, 8421184U, 8429504U, 8437696U,
+        8445376U, 8452544U, 8460736U, 8470208U, 8478016U, 8486848U, 8494144U,
+        8503232U, 8511296U, 8519488U, 8527424U, 8534464U, 8543936U, 8552384U,
+        8558912U, 8568128U, 8575936U, 8584256U, 8593216U, 8601536U, 8608832U,
+        8616896U, 8625728U, 8634176U, 8641856U, 8649664U, 8658112U, 8666176U,
+        8674112U, 8682944U, 8691136U, 8699456U, 8707648U, 8716096U, 8724416U,
+        8732608U, 8740672U, 8748352U, 8756032U, 8764864U, 8773568U, 8781376U,
+        8789824U, 8796992U, 8806208U, 8814272U, 8822336U, 8830912U, 8838848U,
+        8847296U, 8854336U, 8863552U, 8871488U, 8879296U, 8887616U, 8894528U,
+        8904512U, 8911424U, 8920768U, 8928704U, 8936128U, 8944576U, 8953664U,
+        8960576U, 8970176U, 8977984U, 8986304U, 8994112U, 9002432U, 9011008U,
+        9018176U, 9026624U, 9035584U, 9043904U, 9052096U, 9059264U, 9068096U,
+        9075904U, 9084224U, 9092288U, 9100352U, 9108928U, 9116992U, 9125824U,
+        9133504U, 9141824U, 9150272U, 9157952U, 9164608U, 9174848U, 9182912U,
+        9190976U, 9199552U, 9205312U, 9215936U, 9222592U, 9232192U, 9240512U,
+        9248704U, 9256256U, 9264832U, 9272896U, 9281344U, 9288896U, 9297088U,
+        9305536U, 9313984U, 9322304U, 9329728U, 9337792U, 9346112U, 9355072U,
+        9363136U, 9371072U, 9378752U, 9387712U, 9395648U, 9404224U, 9411008U,
+        9420608U, 9428416U, 9436864U, 9445312U, 9453376U, 9460928U, 9468736U,
+        9477824U, 9485248U, 9493696U, 9502144U, 9509056U, 9518528U, 9527104U,
+        9535424U, 9543616U, 9551296U, 9559744U, 9568192U, 9576256U, 9584576U,
+        9591872U, 9600704U, 9608384U, 9615808U, 9624512U, 9633472U, 9641536U,
+        9649856U, 9658048U, 9665728U, 9674432U, 9682496U, 9691072U, 9699136U,
+        9707072U, 9715136U, 9722176U, 9732032U, 9740096U, 9747904U, 9756352U,
+        9764288U, 9771584U, 9780544U, 9789376U, 9796928U, 9804224U, 9813952U,
+        9822016U, 9829696U, 9838016U, 9845824U, 9852992U, 9863104U, 9870656U,
+        9878464U, 9887552U, 9895744U, 9903808U, 9912128U, 9920192U, 9927616U,
+        9936064U, 9944768U, 9952576U, 9960128U, 9969472U, 9977152U, 9985216U,
+        9994048U, 10001216U, 10007744U, 10018496U, 10026944U, 10035136U, 10042432U,
+        10051264U, 10059584U, 10067648U, 10075712U, 10083904U, 10091456U, 10100672U,
+        10108864U, 10116928U, 10124864U, 10133056U, 10140736U, 10149824U, 10156736U,
+        10165952U, 10173376U, 10182208U, 10190528U, 10198336U, 10206272U, 10213696U,
+        10223296U, 10231744U, 10238656U, 10247488U, 10256192U, 10263872U, 10272448U,
+        10280896U, 10288448U, 10296512U, 10305088U, 10313536U, 10321088U, 10330048U,
+        10337984U, 10346176U, 10354112U, 10362304U, 10369088U, 10377152U, 10386752U,
+        10394816U, 10403648U, 10411712U, 10418624U, 10427968U, 10436032U, 10444736U,
+        10452928U, 10459712U, 10468672U, 10476608U, 10484416U, 10491328U, 10501952U,
+        10509376U, 10517824U, 10526528U, 10534336U, 10542656U, 10549696U, 10559168U,
+        10566592U, 10575808U, 10583488U, 10590656U, 10599488U, 10607936U, 10616768U,
+        10624832U, 10630336U, 10640576U, 10649536U, 10655168U, 10665152U, 10674112U,
+        10682176U, 10690496U, 10698176U, 10705216U, 10715072U, 10722752U, 10731328U,
+        10739264U, 10746688U, 10754752U, 10761664U, 10770752U, 10779712U, 10787776U,
+        10796608U, 10803392U, 10812352U, 10821056U, 10828736U, 10837952U, 10846144U,
+        10853824U, 10861376U, 10869952U, 10877248U, 10887104U, 10895296U, 10903232U,
+        10910912U, 10918976U, 10927936U, 10935872U, 10944448U, 10952384U, 10960832U,
+        10968512U, 10977088U, 10985024U, 10992832U, 11000896U, 11009984U, 11018048U,
+        11026112U, 11034304U, 11042624U, 11050432U, 11058368U, 11064512U, 11075392U,
+        11083712U, 11091776U, 11099584U, 11107904U, 11115968U, 11124416U, 11131712U,
+        11141056U, 11148608U, 11157184U, 11165248U, 11173312U, 11180992U, 11189056U,
+        11197376U, 11206592U, 11214656U, 11222336U, 11230784U, 11238464U, 11246528U,
+        11254976U, 11263552U, 11271872U, 11279552U, 11288512U, 11296576U, 11304256U,
+        11312192U, 11320768U, 11329216U, 11336384U, 11345216U, 11352512U, 11362112U,
+        11369408U, 11378624U, 11386688U, 11394496U, 11402816U, 11411264U, 11418688U,
+        11427776U, 11435584U, 11444032U, 11452096U, 11459648U, 11467072U, 11476928U,
+        11484992U, 11493184U, 11500352U, 11509312U, 11517248U, 11524928U, 11534144U,
+        11542208U, 11550272U, 11556416U, 11566784U, 11574208U, 11581376U, 11589568U,
+        11599552U, 11607104U, 11616064U, 11623616U, 11632576U, 11639872U, 11648704U,
+        11657024U, 11664704U, 11672896U, 11681216U, 11689792U, 11697856U, 11705536U,
+        11714368U, 11722688U, 11730496U, 11737408U, 11745728U, 11754304U, 11763008U,
+        11770816U, 11779648U, 11788096U, 11795776U, 11804608U, 11812544U, 11820992U,
+        11829184U, 11837248U, 11844928U, 11852096U, 11860928U, 11869888U, 11878336U,
+        11886272U, 11894336U, 11902144U, 11910848U, 11919296U, 11925952U, 11934784U,
+        11943616U, 11951552U, 11960128U, 11968192U, 11976512U, 11983168U, 11992768U,
+        12000832U, 12008896U, 12016832U, 12025408U, 12033856U, 12042176U, 12049984U,
+        12058048U, 12066112U, 12073792U, 12082624U, 12091328U, 12098752U, 12106816U,
+        12115904U, 12124096U, 12131776U, 12140224U, 12148672U, 12156736U, 12164032U,
+        12173248U, 12181184U, 12186176U, 12197824U, 12205888U, 12213952U, 12218944U,
+        12230336U, 12238784U, 12246592U, 12254272U, 12262336U, 12269888U, 12279104U,
+        12287936U, 12295744U, 12304064U, 12312512U, 12319936U, 12328768U, 12337088U,
+        12344896U, 12352832U, 12361408U, 12368704U, 12377152U, 12384832U, 12394432U,
+        12402496U, 12409024U, 12417728U, 12426688U, 12433216U, 12443584U, 12450752U,
+        12459968U, 12468032U, 12475712U, 12484544U, 12492608U, 12500416U, 12508352U,
+        12517184U, 12525376U, 12532288U, 12541888U, 12549568U, 12556864U, 12565568U,
+        12574528U, 12582208U, 12590528U, 12598592U, 12607424U, 12615488U, 12623552U,
+        12631744U, 12638656U, 12647744U, 12656576U, 12664768U, 12672832U, 12680896U,
+        12688576U, 12697408U, 12704192U, 12713408U, 12721216U, 12729664U, 12738496U,
+        12745792U, 12754496U, 12762688U, 12769472U, 12779456U, 12787648U, 12795712U,
+        12804032U, 12812224U, 12819008U, 12828352U, 12836672U, 12844736U, 12851648U,
+        12859456U, 12868672U, 12877504U, 12885568U, 12892864U, 12902336U, 12909376U,
+        12918208U, 12926656U, 12934976U, 12942784U, 12951104U, 12959552U, 12967744U,
+        12976064U, 12984256U, 12991936U, 12999488U, 13007936U, 13016768U, 13021504U,
+        13033024U, 13041472U, 13049408U, 13057472U, 13065664U, 13072064U, 13081408U,
+        13089344U, 13098688U, 13107008U, 13115072U, 13122752U, 13130944U, 13139648U,
+        13147712U, 13155776U, 13162432U, 13172672U, 13180864U, 13188928U, 13196992U,
+        13203392U, 13213504U, 13219264U, 13228736U, 13236928U, 13244992U, 13253056U,
+        13262528U, 13269952U, 13278784U, 13285952U, 13295552U, 13303616U, 13311808U,
+        13319744U, 13328192U, 13336256U, 13344704U, 13352384U, 13360576U, 13369024U,
+        13377344U, 13385408U, 13393216U, 13401664U, 13410112U, 13418176U, 13426496U,
+        13434688U, 13442368U, 13451072U, 13459136U, 13466944U, 13475648U, 13482944U,
+        13491904U, 13500352U, 13508288U, 13516736U, 13524416U, 13532224U, 13541312U,
+        13549504U, 13556288U, 13564736U, 13573184U, 13581376U, 13587008U, 13598656U,
+        13605952U, 13612864U, 13622464U, 13631168U, 13639616U, 13647808U, 13655104U,
+        13663424U, 13671872U, 13680064U, 13688768U, 13696576U, 13705024U, 13712576U,
+        13721536U, 13729216U, 13737664U, 13746112U, 13753024U, 13759552U, 13770304U,
+        13777856U, 13786688U, 13793984U, 13802176U, 13811264U, 13819328U, 13827904U,
+        13835456U, 13844416U, 13851584U, 13860544U, 13868992U, 13877056U, 13884608U,
+        13893184U, 13901248U, 13909696U, 13917632U, 13925056U, 13934528U, 13942336U,
+        13950784U, 13959104U, 13966912U, 13975232U, 13982656U, 13991872U, 13999936U,
+        14007872U, 14016064U, 14024512U, 14032064U, 14040896U, 14049088U, 14057408U,
+        14065088U, 14072896U, 14081344U, 14089664U, 14097856U, 14106304U, 14114752U,
+        14122688U, 14130752U, 14138816U, 14147008U, 14155072U, 14163904U, 14170432U,
+        14180288U, 14187328U, 14196032U, 14204864U, 14212672U, 14220736U, 14229056U,
+        14237504U, 14245568U, 14253632U, 14261824U, 14269888U, 14278592U, 14286656U,
+        14293696U, 14302784U, 14309696U, 14317504U, 14326336U, 14335936U, 14343232U,
+        14352064U, 14359232U, 14368064U, 14376512U, 14384576U, 14393024U, 14401472U,
+        14409536U, 14416832U, 14424512U, 14433856U, 14440768U, 14449984U, 14458816U,
+        14465728U, 14474816U, 14482112U, 14491328U, 14499392U, 14506816U, 14516032U,
+        14524352U, 14531392U, 14540224U, 14547392U, 14556992U, 14565184U, 14573248U,
+        14580928U, 14588864U, 14596928U, 14606272U, 14613824U, 14622656U, 14630464U,
+        14638912U, 14646976U, 14655296U, 14661952U, 14671808U, 14679872U, 14687936U,
+        14696384U, 14704576U, 14710336U, 14720192U, 14729152U, 14736448U, 14745152U,
+        14752448U, 14761792U, 14769856U, 14777024U, 14785984U, 14792384U, 14802752U,
+        14810816U, 14819264U, 14827328U, 14835136U, 14843072U, 14851264U, 14860096U,
+        14867648U, 14876096U, 14884544U, 14892736U, 14900672U, 14907968U, 14917312U,
+        14924864U, 14933824U, 14939968U, 14950336U, 14957632U, 14966464U, 14974912U,
+        14982592U, 14991296U, 14999104U, 15006272U, 15015232U, 15023936U, 15031616U,
+        15040448U, 15047488U, 15055552U, 15063616U, 15073216U, 15079744U, 15088064U,
+        15097664U, 15105344U, 15113792U, 15122368U, 15130048U, 15137728U, 15146176U,
+        15154112U, 15162688U, 15171392U, 15179456U, 15187264U, 15194176U, 15204032U,
+        15212224U, 15220544U, 15227456U, 15237056U, 15245248U, 15253184U, 15261632U,
+        15269824U, 15277376U, 15285824U, 15293888U, 15301568U, 15310784U, 15318848U,
+        15325504U, 15335104U, 15343168U, 15350848U, 15359936U, 15367232U, 15373376U,
+        15384256U, 15392576U, 15400384U, 15408832U, 15417152U, 15424832U, 15433024U,
+        15441344U, 15449152U, 15457088U, 15466432U, 15474112U, 15482816U, 15488576U,
+        15499072U, 15505856U, 15514816U, 15523264U, 15531584U, 15540032U, 15547328U,
+        15553984U, 15564608U, 15571904U, 15579968U, 15589312U, 15597376U, 15605696U,
+        15612992U, 15621824U, 15630016U, 15638464U, 15646144U, 15654592U, 15662912U,
+        15671104U, 15677248U, 15686848U, 15693376U, 15701696U, 15712064U, 15720256U,
+        15728576U, 15736384U, 15744704U, 15752512U, 15761344U, 15769024U, 15777728U,
+        15785152U, 15793984U, 15802048U, 15809984U, 15817024U, 15825856U, 15834944U,
+        15843008U, 15849664U, 15859136U, 15866432U, 15876032U, 15884096U, 15892288U,
+        15900608U, 15908416U, 15916864U, 15924928U, 15930176U, 15941056U, 15949504U,
+        15957824U, 15965632U, 15973952U, 15982528U, 15990592U, 15998272U, 16006976U,
+        16012736U, 16023104U, 16031296U, 16039616U, 16048064U, 16055744U, 16064192U,
+        16071488U, 16080832U, 16088768U, 16097216U, 16104896U, 16112704U, 16121792U,
+        16129856U, 16138048U, 16146112U, 16154176U, 16162624U, 16170688U, 16177856U,
+        16186816U, 16195136U, 16202176U, 16211648U, 16220096U, 16228288U, 16235584U,
+        16244672U, 16252864U, 16260544U, 16269248U, 16277056U, 16285504U, 16291648U,
+        16301632U, 16309312U, 16318144U, 16326208U, 16333888U, 16342336U, 16351168U,
+        16359232U, 16367552U, 16375616U, 16383296U, 16391744U, 16398016U, 16407616U,
+        16415936U, 16424896U, 16432448U, 16440896U, 16449088U, 16457024U, 16465472U,
+        16474048U, 16481216U, 16490048U, 16498624U, 16505792U, 16513984U, 16523072U,
+        16531136U, 16538944U, 16547264U, 16555328U, 16563776U, 16570816U, 16578112U,
+        16587712U, 16596544U, 16604992U, 16613312U, 16620608U, 16629568U, 16637888U,
+        16645696U, 16653632U, 16661696U, 16669888U, 16677568U, 16686272U, 16695232U,
+        16703168U, 16710464U, 16719424U, 16726592U, 16733888U, 16744384U, 16752448U,
+        16760768U, 16768448U, 16776896U, 16785344U, 16793536U, 16801216U, 16809664U,
+        16818112U, 16826176U, 16833472U, 16842688U, 16850752U, 16859072U, 16866368U,
+        16875328U, 16883392U, 16891712U, 16899776U, 16907456U, 16915264U, 16924352U,
+        16931776U, 16940608U, 16949056U, 16957376U, 16965056U, 16973248U, 16981696U,
+        16990144U, 16997056U, 17005888U, 17014208U, 17021504U, 17031104U, 17039296U,
+        17046976U, 17055424U, 17062592U, 17070016U, 17079488U, 17087936U, 17096512U,
+        17104576U, 17113024U, 17121088U, 17129408U, 17136832U, 17145664U, 17152832U,
+        17161792U, 17170112U, 17177792U, 17186368U, 17194304U, 17202496U, 17211328U,
+        17218624U, 17227712U, 17233984U, 17243584U, 17251904U, 17259712U, 17266624U,
+        17276608U, 17284672U, 17292224U, 17301056U, 17309632U, 17317568U, 17326016U,
+        17333824U, 17342272U, 17350208U, 17358784U, 17366848U, 17374912U, 17382592U,
+        17390656U, 17399488U, 17406784U, 17413952U, 17423936U, 17432512U, 17440448U,
+        17447744U, 17456704U, 17464768U, 17472064U, 17481536U, 17489344U, 17495488U,
+        17505728U, 17513792U, 17522368U, 17530816U, 17538112U, 17546944U, 17555264U,
+        17563072U, 17569856U, 17579456U, 17587904U, 17596352U, 17603776U, 17611712U,
+        17620672U, 17628992U, 17637184U, 17645504U, 17653568U, 17661632U, 17669824U,
+        17677376U, 17686208U, 17693888U, 17702336U, 17710144U, 17718208U, 17726528U,
+        17734336U, 17743808U, 17751872U, 17759936U, 17766592U, 17776448U, 17784512U,
+        17791936U, 17801152U, 17809216U, 17817152U
+};
+
+#ifdef __cplusplus
+}
+#endif

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/ethash.h

@@ -14,6 +14,7 @@
   You should have received a copy of the GNU General Public License
   along with cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
+
 /** @file ethash.h
 * @date 2015
 */
@@ -25,9 +26,10 @@
 #include <stddef.h>
 #include "compiler.h"
 
-#define REVISION 18
+#define REVISION 20
-#define DAGSIZE_BYTES_INIT 1073741824U
+#define DAGSIZE_BYTES_INIT 1073741824U // 2**30
-#define DAG_GROWTH 113000000U
+#define DAG_GROWTH 8388608U            // 2**23
+#define CACHE_MULTIPLIER 1024
 #define EPOCH_LENGTH 30000U
 #define MIX_BYTES 128
 #define DAG_PARENTS 256
@@ -48,8 +50,8 @@ typedef struct ethash_return_value {
     uint8_t mix_hash[32];
 } ethash_return_value;
 
-size_t const ethash_get_datasize(const uint32_t block_number);
+size_t ethash_get_datasize(const uint32_t block_number);
-size_t const ethash_get_cachesize(const uint32_t block_number);
+size_t ethash_get_cachesize(const uint32_t block_number);
 
 // initialize the parameters
 static inline void ethash_params_init(ethash_params *params, const uint32_t block_number) {
@@ -58,7 +60,7 @@ static inline void ethash_params_init(ethash_params *params, const uint32_t bloc
 }
 
 typedef struct ethash_cache {
-    void *mem;
+	void *mem;
 } ethash_cache;
 
 void ethash_mkcache(ethash_cache *cache, ethash_params const *params, const uint8_t seed[32]);
@@ -66,6 +68,11 @@ void ethash_compute_full_data(void *mem, ethash_params const *params, ethash_cac
 void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce);
 void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce);
 
+static inline void ethash_prep_light(void *cache, ethash_params const *params, const uint8_t seed[32]) { ethash_cache c; c.mem = cache; ethash_mkcache(&c, params, seed); }
+static inline void ethash_compute_light(ethash_return_value *ret, void const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) { ethash_cache c; c.mem = (void*)cache; ethash_light(ret, &c, params, header_hash, nonce); }
+static inline void ethash_prep_full(void *full, ethash_params const *params, void const *cache) { ethash_cache c; c.mem = (void*)cache; ethash_compute_full_data(full, params, &c); }
+static inline void ethash_compute_full(ethash_return_value *ret, void const *full, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) { ethash_full(ret, full, params, header_hash, nonce); }
+
 static inline int ethash_check_difficulty(
         const uint8_t hash[32],
         const uint8_t difficulty[32]) {

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c

@@ -31,18 +31,18 @@
 
 #ifdef WITH_CRYPTOPP
 
-#include "SHA3_cryptopp.h"
+#include "sha3_cryptopp.h"
 
 #else
 #include "sha3.h"
 #endif // WITH_CRYPTOPP
 
-size_t const ethash_get_datasize(const uint32_t block_number) {
+size_t ethash_get_datasize(const uint32_t block_number) {
     assert(block_number / EPOCH_LENGTH < 500);
     return dag_sizes[block_number / EPOCH_LENGTH];
 }
 
-size_t const ethash_get_cachesize(const uint32_t block_number) {
+size_t ethash_get_cachesize(const uint32_t block_number) {
     assert(block_number / EPOCH_LENGTH < 500);
     return cache_sizes[block_number / EPOCH_LENGTH];
 }
@@ -283,6 +283,7 @@ int ethash_quick_check_difficulty(
         const uint64_t nonce,
         const uint8_t mix_hash[32],
         const uint8_t difficulty[32]) {
+
     uint8_t return_hash[32];
     ethash_quick_hash(return_hash, header_hash, nonce, mix_hash);
     return ethash_check_difficulty(return_hash, difficulty);

Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c

@@ -0,0 +1,64 @@
+#include <Python.h>
+#include <alloca.h>
+#include <stdint.h>
+#include "../libethash/ethash.h"
+
+static PyObject*
+get_cache_size(PyObject* self, PyObject* args)
+{
+    unsigned long block_number;
+    if (!PyArg_ParseTuple(args, "k", &block_number))
+      return 0;
+    return Py_BuildValue("i", ethash_get_cachesize(block_number));
+}
+
+static PyObject*
+get_full_size(PyObject* self, PyObject* args)
+{
+    unsigned long block_number;
+    if (!PyArg_ParseTuple(args, "k", &block_number))
+      return 0;
+    return Py_BuildValue("i", ethash_get_datasize(block_number));
+}
+
+
+static PyObject*
+mkcache(PyObject* self, PyObject* args)
+{
+    char * seed;
+    unsigned long cache_size;
+    int seed_len;
+
+    if (!PyArg_ParseTuple(args, "ks#", &cache_size, &seed, &seed_len))
+      return 0;
+
+    if (seed_len != 32)
+    {
+      PyErr_SetString(PyExc_ValueError,
+                      "Seed must be 32 bytes long");
+      return 0;
+    }
+
+    printf("cache size: %lu\n", cache_size);
+    ethash_params params;
+    params.cache_size = (size_t) cache_size;
+    ethash_cache cache;
+    cache.mem = alloca(cache_size);
+    ethash_mkcache(&cache, &params, (uint8_t *) seed);
+    return PyString_FromStringAndSize(cache.mem, cache_size);
+}
+
+
+static PyMethodDef CoreMethods[] =
+{
+     {"get_cache_size", get_cache_size, METH_VARARGS, "Get the cache size for a given block number"},
+     {"get_full_size", get_full_size, METH_VARARGS, "Get the full size for a given block number"},
+     {"mkcache", mkcache, METH_VARARGS, "Makes the cache for given parameters and seed hash"},
+     {NULL, NULL, 0, NULL}
+};
+
+PyMODINIT_FUNC
+initcore(void)
+{
+     (void) Py_InitModule("core", CoreMethods);
+}

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt

@@ -4,7 +4,7 @@ ENDIF()
 
 IF( Boost_FOUND )
     include_directories( ${Boost_INCLUDE_DIR} )
-    include_directories(..)
+    include_directories(../../src)
 
     link_directories ( ${Boost_LIBRARY_DIRS} )
     file(GLOB HEADERS "*.h")

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp

@@ -13,7 +13,6 @@
 #define BOOST_TEST_MAIN
 
 #include <boost/test/unit_test.hpp>
-#include <libethash/ethash.h>
 #include <iostream>
 
 std::string bytesToHexString(const uint8_t *str, const size_t s) {
@@ -90,24 +89,6 @@ BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_calcifide_check) {
                     << "actual: " << params.cache_size << "\n");
 }
 
-BOOST_AUTO_TEST_CASE(ethash_params_init_check) {
-    ethash_params params;
-    ethash_params_init(&params, 1971000);
-    const uint64_t nine_month_size = (uint64_t) 8*DAGSIZE_BYTES_INIT;
-    BOOST_REQUIRE_MESSAGE(params.full_size  < nine_month_size,
-            "\nfull size: " << params.full_size << "\n"
-                    << "should be less than or equal to: " << nine_month_size << "\n");
-    BOOST_REQUIRE_MESSAGE(params.full_size + DAGSIZE_BYTES_INIT / 4 > nine_month_size,
-            "\nfull size + DAGSIZE_BYTES_INIT / 4: " << params.full_size + DAGSIZE_BYTES_INIT / 4 << "\n"
-                    << "should be greater than or equal to: " << nine_month_size << "\n");
-    BOOST_REQUIRE_MESSAGE(params.cache_size < nine_month_size / 1024,
-            "\nactual cache size: " << params.cache_size << "\n"
-                    << "expected: " << nine_month_size / 1024 << "\n");
-    BOOST_REQUIRE_MESSAGE(params.cache_size + DAGSIZE_BYTES_INIT / 4 / 1024 > nine_month_size / 1024 ,
-            "\ncache size + DAGSIZE_BYTES_INIT / 4 / 1024: " << params.cache_size + DAGSIZE_BYTES_INIT / 4 / 1024 << "\n"
-                    << "actual: " << nine_month_size / 32 << "\n");
-}
-
 BOOST_AUTO_TEST_CASE(light_and_full_client_checks) {
     ethash_params params;
     uint8_t seed[32], hash[32];

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Strict mode
+set -e
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+rm -rf $TEST_DIR/build 
+mkdir -p $TEST_DIR/build 
+cd $TEST_DIR/build ; 
+cmake ../../.. > /dev/null 
+make Test 
+./test/c/Test

Godeps/_workspace/src/github.com/ethereum/ethash/test/go/ethash_test.go

@@ -1,54 +0,0 @@
-package ethashTest
-
-import (
-	"bytes"
-	"crypto/rand"
-	"log"
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/ethash"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/ethdb"
-)
-
-func TestEthash(t *testing.T) {
-	seedHash := make([]byte, 32)
-	_, err := rand.Read(seedHash)
-	if err != nil {
-		panic(err)
-	}
-
-	db, err := ethdb.NewMemDatabase()
-	if err != nil {
-		panic(err)
-	}
-
-	blockProcessor, err := core.NewCanonical(5, db)
-	if err != nil {
-		panic(err)
-	}
-
-	log.Println("Block Number: ", blockProcessor.ChainManager().CurrentBlock().Number())
-
-	e := ethash.New(blockProcessor.ChainManager())
-
-	miningHash := make([]byte, 32)
-	if _, err := rand.Read(miningHash); err != nil {
-		panic(err)
-	}
-	diff := big.NewInt(10000)
-	log.Println("difficulty", diff)
-
-	nonce := uint64(0)
-
-	ghash_full := e.FullHash(nonce, miningHash)
-	log.Printf("ethash full (on nonce): %x %x\n", ghash_full, nonce)
-
-	ghash_light := e.LightHash(nonce, miningHash)
-	log.Printf("ethash light (on nonce): %x %x\n", ghash_light, nonce)
-
-	if bytes.Compare(ghash_full, ghash_light) != 0 {
-		t.Errorf("full: %x, light: %x", ghash_full, ghash_light)
-	}
-}

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore

@@ -0,0 +1 @@
+python-virtual-env/

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt

@@ -0,0 +1,2 @@
+pyethereum==0.7.522
+nose==1.3.4

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Strict mode
+set -e
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+[ -d $TEST_DIR/python-virtual-env ] || virtualenv --system-site-packages $TEST_DIR/python-virtual-env
+source $TEST_DIR/python-virtual-env/bin/activate
+pip install -r $TEST_DIR/requirements.txt > /dev/null
+pip install -e $TEST_DIR/../.. > /dev/null
+cd $TEST_DIR
+nosetests --with-doctest -v

Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py

@@ -0,0 +1,45 @@
+import pyethash
+from random import randint
+
+def test_get_cache_size_not_None():
+    for _ in range(100):
+        block_num = randint(0,12456789)
+        out = pyethash.core.get_cache_size(block_num)
+        assert out != None
+
+def test_get_full_size_not_None():
+    for _ in range(100):
+        block_num = randint(0,12456789)
+        out = pyethash.core.get_full_size(block_num)
+        assert out != None
+
+def test_get_cache_size_based_on_EPOCH():
+    for _ in range(100):
+        block_num = randint(0,12456789)
+        out1 = pyethash.core.get_cache_size(block_num)
+        out2 = pyethash.core.get_cache_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
+        assert out1 == out2
+
+def test_get_full_size_based_on_EPOCH():
+    for _ in range(100):
+        block_num = randint(0,12456789)
+        out1 = pyethash.core.get_full_size(block_num)
+        out2 = pyethash.core.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
+        assert out1 == out2
+
+#def test_get_params_based_on_EPOCH():
+#    block_num = 123456
+#    out1 = pyethash.core.get_params(block_num)
+#    out2 = pyethash.core.get_params((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
+#    assert out1["DAG Size"] == out2["DAG Size"]
+#    assert out1["Cache Size"] == out2["Cache Size"]
+#
+#def test_get_params_returns_different_values_based_on_different_block_input():
+#    out1 = pyethash.core.get_params(123456)
+#    out2 = pyethash.core.get_params(12345)
+#    assert out1["DAG Size"] != out2["DAG Size"]
+#    assert out1["Cache Size"] != out2["Cache Size"]
+#
+#def test_get_cache_smoke_test():
+#    params = pyethash.core.get_params(123456)
+#    assert pyethash.core.mkcache(params, "~~~~") != None

Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Strict mode
+set -e
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+echo -e "\n################# Testing JS ##################"
+# TODO: Use mocha and real testing tools instead of rolling our own
+cd $TEST_DIR/../js 
+node test.js
+
+echo -e "\n################# Testing C ##################"
+$TEST_DIR/c/test.sh
+
+echo -e "\n################# Testing Python ##################"
+$TEST_DIR/python/test.sh
+
+#echo "################# Testing Go ##################"
+#$TEST_DIR/go/test.sh