Merge branch 'develop' into p2p

Conflicts: libp2p/Session.cpp
10 years ago · 68e3895c41
50 changed files with 1268 additions and 761 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -131,11 +131,15 @@ endif()
 add_subdirectory(libdevcore)
 add_subdirectory(libevmcore)
 add_subdirectory(liblll)
-add_subdirectory(libserpent)
+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
+	add_subdirectory(libserpent)
+endif ()
 add_subdirectory(libsolidity)
 add_subdirectory(lllc)
 add_subdirectory(solc)
+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
 add_subdirectory(sc)
+endif()

 if (JSONRPC)
 	add_subdirectory(libweb3jsonrpc)
--- a/alethzero/CMakeLists.txt
+++ b/alethzero/CMakeLists.txt
@ -40,7 +40,9 @@ target_link_libraries(${EXECUTABLE} evm)
 target_link_libraries(${EXECUTABLE} ethcore)
 target_link_libraries(${EXECUTABLE} devcrypto)
 target_link_libraries(${EXECUTABLE} secp256k1)
+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
 target_link_libraries(${EXECUTABLE} serpent)
+endif()
 target_link_libraries(${EXECUTABLE} lll)
 target_link_libraries(${EXECUTABLE} solidity)
 target_link_libraries(${EXECUTABLE} evmcore)
--- a/alethzero/MainWin.cpp
+++ b/alethzero/MainWin.cpp
@ -30,8 +30,10 @@
 #include <QtCore/QtCore>
 #include <boost/algorithm/string.hpp>
 #include <test/JsonSpiritHeaders.h>
+#ifndef _MSC_VER
 #include <libserpent/funcs.h>
 #include <libserpent/util.h>
+#endif
 #include <libdevcrypto/FileSystem.h>
 #include <libethcore/CommonJS.h>
 #include <liblll/Compiler.h>
@ -1716,6 +1718,7 @@ void Main::on_data_textChanged()
 				solidity = "<h4>Solidity</h4><pre>Uncaught exception.</pre>";
 			}
 		}
+#ifndef _MSC_VER
 		else if (sourceIsSerpent(src))
 		{
 			try
@ -1729,6 +1732,7 @@ void Main::on_data_textChanged()
 				errors.push_back("Serpent " + err);
 			}
 		}
+#endif
 		else
 		{
 			m_data = compileLLL(src, m_enableOptimizer, &errors);
--- a/evmjit/CMakeLists.txt
+++ b/evmjit/CMakeLists.txt
@ -4,7 +4,7 @@ project(evmjit)

 set_property(GLOBAL PROPERTY USE_FOLDERS ON)

-if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 else()
 	set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra -fPIC")
 endif()
@ -32,9 +32,6 @@ else()
 	link_directories(/usr/lib/llvm-3.5/lib)
 endif()

-# Boost
-find_package(Boost REQUIRED)
-
 add_subdirectory(libevmjit)

 if(EVMJIT_CPP)
--- a/evmjit/libevmjit-cpp/CMakeLists.txt
+++ b/evmjit/libevmjit-cpp/CMakeLists.txt
@ -1,5 +1,8 @@
 set(TARGET_NAME evmjit-cpp)

+# Boost
+find_package(Boost REQUIRED)
+
 set(SOURCES
    Env.cpp     
    JitVM.cpp   JitVM.h
--- a/evmjit/libevmjit-cpp/Env.cpp
+++ b/evmjit/libevmjit-cpp/Env.cpp
@ -3,7 +3,7 @@
 #include <libevm/FeeStructure.h>
 #include <libevm/ExtVMFace.h>

-#include <evmjit/libevmjit/Utils.h>
+#include "Utils.h"

 extern "C"
 {
@ -16,7 +16,6 @@ extern "C"
 	using namespace dev;
 	using namespace dev::eth;
 	using jit::i256;
-	using jit::eth2llvm;

 	EXPORT void env_sload(ExtVMFace* _env, i256* _index, i256* o_value)
 	{
--- a/evmjit/libevmjit-cpp/JitVM.cpp
+++ b/evmjit/libevmjit-cpp/JitVM.cpp
@ -2,39 +2,54 @@
 #include "JitVM.h"
 #include <libevm/VM.h>
 #include <evmjit/libevmjit/ExecutionEngine.h>
-#include <evmjit/libevmjit/Utils.h>
+#include "Utils.h"

 namespace dev
 {
 namespace eth
 {

+extern "C" void env_sload(); // fake declaration for linker symbol stripping workaround, see a call below
+
 bytesConstRef JitVM::go(ExtVMFace& _ext, OnOpFunc const&, uint64_t)
 {
 	using namespace jit;

-	m_data.set(RuntimeData::Gas, m_gas);
-	m_data.set(RuntimeData::Address, fromAddress(_ext.myAddress));
-	m_data.set(RuntimeData::Caller, fromAddress(_ext.caller));
-	m_data.set(RuntimeData::Origin, fromAddress(_ext.origin));
-	m_data.set(RuntimeData::CallValue, _ext.value);
-	m_data.set(RuntimeData::CallDataSize, _ext.data.size());
-	m_data.set(RuntimeData::GasPrice, _ext.gasPrice);
-	m_data.set(RuntimeData::CoinBase, fromAddress(_ext.currentBlock.coinbaseAddress));
-	m_data.set(RuntimeData::TimeStamp, _ext.currentBlock.timestamp);
-	m_data.set(RuntimeData::Number, _ext.currentBlock.number);
-	m_data.set(RuntimeData::Difficulty, _ext.currentBlock.difficulty);
-	m_data.set(RuntimeData::GasLimit, _ext.currentBlock.gasLimit);
-	m_data.set(RuntimeData::CodeSize, _ext.code.size());
+	if (m_gas > std::numeric_limits<decltype(m_data.gas)>::max())
+		BOOST_THROW_EXCEPTION(OutOfGas()); // Do not accept requests with gas > 2^63 (int64 max) // TODO: Return "not accepted" exception to allow interpreted handle that
+
+	if (_ext.gasPrice > std::numeric_limits<decltype(m_data.gasPrice)>::max())
+		BOOST_THROW_EXCEPTION(OutOfGas());
+
+	if (_ext.currentBlock.number > std::numeric_limits<decltype(m_data.number)>::max())
+		BOOST_THROW_EXCEPTION(OutOfGas());
+
+	if (_ext.currentBlock.timestamp > std::numeric_limits<decltype(m_data.timestamp)>::max())
+		BOOST_THROW_EXCEPTION(OutOfGas());
+
+
+	m_data.gas 			= static_cast<decltype(m_data.gas)>(m_gas);
+	m_data.gasPrice		= static_cast<decltype(m_data.gasPrice)>(_ext.gasPrice);
 	m_data.callData 	= _ext.data.data();
+	m_data.callDataSize = _ext.data.size();
+	m_data.address      = eth2llvm(fromAddress(_ext.myAddress));
+	m_data.caller       = eth2llvm(fromAddress(_ext.caller));
+	m_data.origin       = eth2llvm(fromAddress(_ext.origin));
+	m_data.callValue    = eth2llvm(_ext.value);
+	m_data.coinBase     = eth2llvm(fromAddress(_ext.currentBlock.coinbaseAddress));
+	m_data.difficulty   = eth2llvm(_ext.currentBlock.difficulty);
+	m_data.gasLimit     = eth2llvm(_ext.currentBlock.gasLimit);
+	m_data.number 		= static_cast<decltype(m_data.number)>(_ext.currentBlock.number);
+	m_data.timestamp 	= static_cast<decltype(m_data.timestamp)>(_ext.currentBlock.timestamp);
 	m_data.code     	= _ext.code.data();
+	m_data.codeSize 	= _ext.code.size();

 	auto env = reinterpret_cast<Env*>(&_ext);
 	auto exitCode = m_engine.run(_ext.code, &m_data, env);
 	switch (exitCode)
 	{
 	case ReturnCode::Suicide:
-		_ext.suicide(right160(m_data.get(RuntimeData::SuicideDestAddress)));
+		_ext.suicide(right160(llvm2eth(m_data.address)));
 		break;

 	case ReturnCode::BadJumpDestination:
@ -45,24 +60,16 @@ bytesConstRef JitVM::go(ExtVMFace& _ext, OnOpFunc const&, uint64_t)
 		BOOST_THROW_EXCEPTION(StackTooSmall());
 	case ReturnCode::BadInstruction:
 		BOOST_THROW_EXCEPTION(BadInstruction());
+	case ReturnCode::LinkerWorkaround:	// never happens
+		env_sload();					// but forces linker to include env_* JIT callback functions
+		break;
 	default:
 		break;
 	}

-	m_gas = llvm2eth(m_data.elems[RuntimeData::Gas]);
-	return {m_engine.returnData.data(), m_engine.returnData.size()};  // TODO: This all bytesConstRef is problematic, review.
+	m_gas = m_data.gas; // TODO: Remove m_gas field
+	return {std::get<0>(m_engine.returnData), std::get<1>(m_engine.returnData)};
 }

 }
 }
-
-namespace
-{
-	// MSVS linker ignores export symbols in Env.cpp if nothing points at least one of them
-	extern "C" void env_sload();
-	void linkerWorkaround() 
-	{ 
-		env_sload();
-		(void)&linkerWorkaround; // suppress unused function warning from GCC
-	}
-}
--- a/evmjit/libevmjit-cpp/Utils.h
+++ b/evmjit/libevmjit-cpp/Utils.h
@ -0,0 +1,38 @@
+#pragma once
+
+#include <evmjit/libevmjit/Common.h>
+
+namespace dev
+{
+namespace eth
+{
+
+inline u256 llvm2eth(jit::i256 _i)
+{
+	u256 u = 0;
+	u |= _i.d;
+	u <<= 64;
+	u |= _i.c;
+	u <<= 64;
+	u |= _i.b;
+	u <<= 64;
+	u |= _i.a;
+	return u;
+}
+
+inline jit::i256 eth2llvm(u256 _u)
+{
+	jit::i256 i;
+	u256 mask = 0xFFFFFFFFFFFFFFFF;
+	i.a = static_cast<uint64_t>(_u & mask);
+	_u >>= 64;
+	i.b = static_cast<uint64_t>(_u & mask);
+	_u >>= 64;
+	i.c = static_cast<uint64_t>(_u & mask);
+	_u >>= 64;
+	i.d = static_cast<uint64_t>(_u & mask);
+	return i;
+}
+
+}
+}
--- a/evmjit/libevmjit/Arith256.cpp
+++ b/evmjit/libevmjit/Arith256.cpp
@ -1,8 +1,11 @@
 #include "Arith256.h"
 #include "Runtime.h"
 #include "Type.h"
+#include "Endianness.h"

 #include <llvm/IR/Function.h>
+#include <llvm/IR/IntrinsicInst.h>
+#include <iostream>

 namespace dev
 {
@ -24,35 +27,257 @@ Arith256::Arith256(llvm::IRBuilder<>& _builder) :
 	using Linkage = GlobalValue::LinkageTypes;

 	llvm::Type* arg2Types[] = {Type::WordPtr, Type::WordPtr, Type::WordPtr};
-	llvm::Type* arg3Types[] = {Type::WordPtr, Type::WordPtr, Type::WordPtr, Type::WordPtr};

 	m_mul = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_mul", getModule());
-	m_div = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_div", getModule());
-	m_mod = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_mod", getModule());
-	m_sdiv = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_sdiv", getModule());
-	m_smod = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_smod", getModule());
-	m_exp = Function::Create(FunctionType::get(Type::Void, arg2Types, false), Linkage::ExternalLinkage, "arith_exp", getModule());
-	m_addmod = Function::Create(FunctionType::get(Type::Void, arg3Types, false), Linkage::ExternalLinkage, "arith_addmod", getModule());
-	m_mulmod = Function::Create(FunctionType::get(Type::Void, arg3Types, false), Linkage::ExternalLinkage, "arith_mulmod", getModule());
 }

-Arith256::~Arith256()
-{}
+void Arith256::debug(llvm::Value* _value, char _c)
+{
+	if (!m_debug)
+	{
+		llvm::Type* argTypes[] = {Type::Word, m_builder.getInt8Ty()};
+		m_debug = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::ExternalLinkage, "debug", getModule());
+	}
+	createCall(m_debug, {_value, m_builder.getInt8(_c)});
+}

-llvm::Value* Arith256::binaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2)
+llvm::Function* Arith256::getDivFunc(llvm::Type* _type)
 {
-	m_builder.CreateStore(_arg1, m_arg1);
-	m_builder.CreateStore(_arg2, m_arg2);
-	m_builder.CreateCall3(_op, m_arg1, m_arg2, m_result);
-	return m_builder.CreateLoad(m_result);
+	auto& func = _type == Type::Word ? m_div : m_div512;
+
+	if (!func)
+	{
+		// Based of "Improved shift divisor algorithm" from "Software Integer Division" by Microsoft Research
+		// The following algorithm also handles divisor of value 0 returning 0 for both quotient and reminder
+
+		llvm::Type* argTypes[] = {_type, _type};
+		auto retType = llvm::StructType::get(m_builder.getContext(), llvm::ArrayRef<llvm::Type*>{argTypes});
+		auto funcName = _type == Type::Word ? "div" : "div512";
+		func = llvm::Function::Create(llvm::FunctionType::get(retType, argTypes, false), llvm::Function::PrivateLinkage, funcName, getModule());
+
+		auto zero = llvm::ConstantInt::get(_type, 0);
+		auto one = llvm::ConstantInt::get(_type, 1);
+
+		auto x = &func->getArgumentList().front();
+		x->setName("x");
+		auto yArg = x->getNextNode();
+		yArg->setName("y");
+
+		InsertPointGuard guard{m_builder};
+
+		auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), "Entry", func);
+		auto mainBB = llvm::BasicBlock::Create(m_builder.getContext(), "Main", func);
+		auto loopBB = llvm::BasicBlock::Create(m_builder.getContext(), "Loop", func);
+		auto continueBB = llvm::BasicBlock::Create(m_builder.getContext(), "Continue", func);
+		auto returnBB = llvm::BasicBlock::Create(m_builder.getContext(), "Return", func);
+
+		m_builder.SetInsertPoint(entryBB);
+		auto yNonZero = m_builder.CreateICmpNE(yArg, zero);
+		auto yLEx = m_builder.CreateICmpULE(yArg, x);
+		auto r0 = m_builder.CreateSelect(yNonZero, x, zero, "r0");
+		m_builder.CreateCondBr(m_builder.CreateAnd(yLEx, yNonZero), mainBB, returnBB);
+
+		m_builder.SetInsertPoint(mainBB);
+		auto ctlzIntr = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::ctlz, _type);
+		// both y and r are non-zero
+		auto yLz = m_builder.CreateCall2(ctlzIntr, yArg, m_builder.getInt1(true), "y.lz");
+		auto rLz = m_builder.CreateCall2(ctlzIntr, r0, m_builder.getInt1(true), "r.lz");
+		auto i0 = m_builder.CreateNUWSub(yLz, rLz, "i0");
+		auto shlBy0 = m_builder.CreateICmpEQ(i0, zero);
+		auto y0 = m_builder.CreateShl(yArg, i0);
+		y0 = m_builder.CreateSelect(shlBy0, yArg, y0, "y0"); // Workaround for LLVM bug: shl by 0 produces wrong result
+		m_builder.CreateBr(loopBB);
+
+		m_builder.SetInsertPoint(loopBB);
+		auto yPhi = m_builder.CreatePHI(_type, 2, "y.phi");
+		auto rPhi = m_builder.CreatePHI(_type, 2, "r.phi");
+		auto iPhi = m_builder.CreatePHI(_type, 2, "i.phi");
+		auto qPhi = m_builder.CreatePHI(_type, 2, "q.phi");
+		auto rUpdate = m_builder.CreateNUWSub(rPhi, yPhi);
+		auto qUpdate = m_builder.CreateOr(qPhi, one);	// q += 1, q lowest bit is 0
+		auto rGEy = m_builder.CreateICmpUGE(rPhi, yPhi);
+		auto r1 = m_builder.CreateSelect(rGEy, rUpdate, rPhi, "r1");
+		auto q1 = m_builder.CreateSelect(rGEy, qUpdate, qPhi, "q");
+		auto iZero = m_builder.CreateICmpEQ(iPhi, zero);
+		m_builder.CreateCondBr(iZero, returnBB, continueBB);
+
+		m_builder.SetInsertPoint(continueBB);
+		auto i2 = m_builder.CreateNUWSub(iPhi, one);
+		auto q2 = m_builder.CreateShl(q1, one);
+		auto y2 = m_builder.CreateLShr(yPhi, one);
+		m_builder.CreateBr(loopBB);
+
+		yPhi->addIncoming(y0, mainBB);
+		yPhi->addIncoming(y2, continueBB);
+		rPhi->addIncoming(r0, mainBB);
+		rPhi->addIncoming(r1, continueBB);
+		iPhi->addIncoming(i0, mainBB);
+		iPhi->addIncoming(i2, continueBB);
+		qPhi->addIncoming(zero, mainBB);
+		qPhi->addIncoming(q2, continueBB);
+
+		m_builder.SetInsertPoint(returnBB);
+		auto qRet = m_builder.CreatePHI(_type, 2, "q.ret");
+		qRet->addIncoming(zero, entryBB);
+		qRet->addIncoming(q1, loopBB);
+		auto rRet = m_builder.CreatePHI(_type, 2, "r.ret");
+		rRet->addIncoming(r0, entryBB);
+		rRet->addIncoming(r1, loopBB);
+		auto ret = m_builder.CreateInsertValue(llvm::UndefValue::get(retType), qRet, 0, "ret0");
+		ret = m_builder.CreateInsertValue(ret, rRet, 1, "ret");
+		m_builder.CreateRet(ret);
+	}
+	return func;
+}
+
+llvm::Function* Arith256::getExpFunc()
+{
+	if (!m_exp)
+	{
+		llvm::Type* argTypes[] = {Type::Word, Type::Word};
+		m_exp = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, "arith.exp", getModule());
+
+		auto base = &m_exp->getArgumentList().front();
+		base->setName("base");
+		auto exponent = base->getNextNode();
+		exponent->setName("exponent");
+
+		InsertPointGuard guard{m_builder};
+
+		//	while (e != 0) {
+		//		if (e % 2 == 1)
+		//			r *= b;
+		//		b *= b;
+		//		e /= 2;
+		//	}
+
+		auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), "Entry", m_exp);
+		auto headerBB = llvm::BasicBlock::Create(m_builder.getContext(), "LoopHeader", m_exp);
+		auto bodyBB = llvm::BasicBlock::Create(m_builder.getContext(), "LoopBody", m_exp);
+		auto updateBB = llvm::BasicBlock::Create(m_builder.getContext(), "ResultUpdate", m_exp);
+		auto continueBB = llvm::BasicBlock::Create(m_builder.getContext(), "Continue", m_exp);
+		auto returnBB = llvm::BasicBlock::Create(m_builder.getContext(), "Return", m_exp);
+
+		m_builder.SetInsertPoint(entryBB);
+		auto a1 = m_builder.CreateAlloca(Type::Word, nullptr, "a1");
+		auto a2 = m_builder.CreateAlloca(Type::Word, nullptr, "a2");
+		auto a3 = m_builder.CreateAlloca(Type::Word, nullptr, "a3");
+		m_builder.CreateBr(headerBB);
+
+		m_builder.SetInsertPoint(headerBB);
+		auto r = m_builder.CreatePHI(Type::Word, 2, "r");
+		auto b = m_builder.CreatePHI(Type::Word, 2, "b");
+		auto e = m_builder.CreatePHI(Type::Word, 2, "e");
+		auto eNonZero = m_builder.CreateICmpNE(e, Constant::get(0), "e.nonzero");
+		m_builder.CreateCondBr(eNonZero, bodyBB, returnBB);
+
+		m_builder.SetInsertPoint(bodyBB);
+		auto eOdd = m_builder.CreateICmpNE(m_builder.CreateAnd(e, Constant::get(1)), Constant::get(0), "e.isodd");
+		m_builder.CreateCondBr(eOdd, updateBB, continueBB);
+
+		m_builder.SetInsertPoint(updateBB);
+		m_builder.CreateStore(r, a1);
+		m_builder.CreateStore(b, a2);
+		createCall(m_mul, {a1, a2, a3});
+		auto r0 = m_builder.CreateLoad(a3, "r0");
+		m_builder.CreateBr(continueBB);
+
+		m_builder.SetInsertPoint(continueBB);
+		auto r1 = m_builder.CreatePHI(Type::Word, 2, "r1");
+		r1->addIncoming(r, bodyBB);
+		r1->addIncoming(r0, updateBB);
+		m_builder.CreateStore(b, a1);
+		m_builder.CreateStore(b, a2);
+		createCall(m_mul, {a1, a2, a3});
+		auto b1 = m_builder.CreateLoad(a3, "b1");
+		auto e1 = m_builder.CreateLShr(e, Constant::get(1), "e1");
+		m_builder.CreateBr(headerBB);
+
+		r->addIncoming(Constant::get(1), entryBB);
+		r->addIncoming(r1, continueBB);
+		b->addIncoming(base, entryBB);
+		b->addIncoming(b1, continueBB);
+		e->addIncoming(exponent, entryBB);
+		e->addIncoming(e1, continueBB);
+
+		m_builder.SetInsertPoint(returnBB);
+		m_builder.CreateRet(r);
+	}
+	return m_exp;
+}
+
+llvm::Function* Arith256::getAddModFunc()
+{
+	if (!m_addmod)
+	{
+		auto i512Ty = m_builder.getIntNTy(512);
+		llvm::Type* argTypes[] = {Type::Word, Type::Word, Type::Word};
+		m_addmod = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, "addmod", getModule());
+
+		auto x = &m_addmod->getArgumentList().front();
+		x->setName("x");
+		auto y = x->getNextNode();
+		y->setName("y");
+		auto mod = y->getNextNode();
+		mod->setName("m");
+
+		InsertPointGuard guard{m_builder};
+
+		auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), {}, m_addmod);
+		m_builder.SetInsertPoint(entryBB);
+		auto x512 = m_builder.CreateZExt(x, i512Ty, "x512");
+		auto y512 = m_builder.CreateZExt(y, i512Ty, "y512");
+		auto m512 = m_builder.CreateZExt(mod, i512Ty, "m512");
+		auto s = m_builder.CreateAdd(x512, y512, "s");
+		auto d = createCall(getDivFunc(i512Ty), {s, m512});
+		auto r = m_builder.CreateExtractValue(d, 1, "r");
+		m_builder.CreateRet(m_builder.CreateTrunc(r, Type::Word));
+	}
+	return m_addmod;
+}
+
+llvm::Function* Arith256::getMulModFunc()
+{
+	if (!m_mulmod)
+	{
+		llvm::Type* argTypes[] = {Type::Word, Type::Word, Type::Word};
+		m_mulmod = llvm::Function::Create(llvm::FunctionType::get(Type::Word, argTypes, false), llvm::Function::PrivateLinkage, "mulmod", getModule());
+
+		auto i512Ty = m_builder.getIntNTy(512);
+		llvm::Type* mul512ArgTypes[] = {Type::WordPtr, Type::WordPtr, i512Ty->getPointerTo()};
+		auto mul512 = llvm::Function::Create(llvm::FunctionType::get(Type::Void, mul512ArgTypes, false), llvm::Function::ExternalLinkage, "arith_mul512", getModule());
+
+		auto x = &m_mulmod->getArgumentList().front();
+		x->setName("x");
+		auto y = x->getNextNode();
+		y->setName("y");
+		auto mod = y->getNextNode();
+		mod->setName("mod");
+
+		InsertPointGuard guard{m_builder};
+
+		auto entryBB = llvm::BasicBlock::Create(m_builder.getContext(), {}, m_mulmod);
+		m_builder.SetInsertPoint(entryBB);
+		auto a1 = m_builder.CreateAlloca(Type::Word);
+		auto a2 = m_builder.CreateAlloca(Type::Word);
+		auto a3 = m_builder.CreateAlloca(i512Ty);
+		m_builder.CreateStore(x, a1);
+		m_builder.CreateStore(y, a2);
+		createCall(mul512, {a1, a2, a3});
+		auto p = m_builder.CreateLoad(a3, "p");
+		auto m = m_builder.CreateZExt(mod, i512Ty, "m");
+		auto d = createCall(getDivFunc(i512Ty), {p, m});
+		auto r = m_builder.CreateExtractValue(d, 1, "r");
+		m_builder.CreateRet(m_builder.CreateTrunc(r, Type::Word));
+	}
+	return m_mulmod;
 }

-llvm::Value* Arith256::ternaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3)
+llvm::Value* Arith256::binaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2)
 {
 	m_builder.CreateStore(_arg1, m_arg1);
 	m_builder.CreateStore(_arg2, m_arg2);
-	m_builder.CreateStore(_arg3, m_arg3);
-	m_builder.CreateCall4(_op, m_arg1, m_arg2, m_arg3, m_result);
+	m_builder.CreateCall3(_op, m_arg1, m_arg2, m_result);
 	return m_builder.CreateLoad(m_result);
 }

@ -61,140 +286,223 @@ llvm::Value* Arith256::mul(llvm::Value* _arg1, llvm::Value* _arg2)
 	return binaryOp(m_mul, _arg1, _arg2);
 }

-llvm::Value* Arith256::div(llvm::Value* _arg1, llvm::Value* _arg2)
+std::pair<llvm::Value*, llvm::Value*> Arith256::div(llvm::Value* _arg1, llvm::Value* _arg2)
 {
-	return binaryOp(m_div, _arg1, _arg2);
+	auto div =  m_builder.CreateExtractValue(createCall(getDivFunc(Type::Word), {_arg1, _arg2}), 0, "div");
+	auto mod =  m_builder.CreateExtractValue(createCall(getDivFunc(Type::Word), {_arg1, _arg2}), 1, "mod");
+	return std::make_pair(div, mod);
 }

-llvm::Value* Arith256::mod(llvm::Value* _arg1, llvm::Value* _arg2)
+std::pair<llvm::Value*, llvm::Value*> Arith256::sdiv(llvm::Value* _x, llvm::Value* _y)
 {
-	return binaryOp(m_mod, _arg1, _arg2);
-}
+	auto xIsNeg = m_builder.CreateICmpSLT(_x, Constant::get(0));
+	auto xNeg = m_builder.CreateSub(Constant::get(0), _x);
+	auto xAbs = m_builder.CreateSelect(xIsNeg, xNeg, _x);

-llvm::Value* Arith256::sdiv(llvm::Value* _arg1, llvm::Value* _arg2)
-{
-	return binaryOp(m_sdiv, _arg1, _arg2);
-}
+	auto yIsNeg = m_builder.CreateICmpSLT(_y, Constant::get(0));
+	auto yNeg = m_builder.CreateSub(Constant::get(0), _y);
+	auto yAbs = m_builder.CreateSelect(yIsNeg, yNeg, _y);

-llvm::Value* Arith256::smod(llvm::Value* _arg1, llvm::Value* _arg2)
-{
-	return binaryOp(m_smod, _arg1, _arg2);
+	auto res = div(xAbs, yAbs);
+
+	// the reminder has the same sign as dividend
+	auto rNeg = m_builder.CreateSub(Constant::get(0), res.second);
+	res.second = m_builder.CreateSelect(xIsNeg, rNeg, res.second);
+
+	auto qNeg = m_builder.CreateSub(Constant::get(0), res.first);
+	auto xyOpposite = m_builder.CreateXor(xIsNeg, yIsNeg);
+	res.first = m_builder.CreateSelect(xyOpposite, qNeg, res.first);
+
+	return res;
 }

 llvm::Value* Arith256::exp(llvm::Value* _arg1, llvm::Value* _arg2)
 {
-	return binaryOp(m_exp, _arg1, _arg2);
+	return createCall(getExpFunc(), {_arg1, _arg2});
 }

 llvm::Value* Arith256::addmod(llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3)
 {
-	return ternaryOp(m_addmod, _arg1, _arg2, _arg3);
+	return createCall(getAddModFunc(), {_arg1, _arg2, _arg3});
 }

 llvm::Value* Arith256::mulmod(llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3)
 {
-	return ternaryOp(m_mulmod, _arg1, _arg2, _arg3);
+	return createCall(getMulModFunc(), {_arg1, _arg2, _arg3});
 }

 namespace
 {
-	using s256 = boost::multiprecision::int256_t;
+#ifdef __SIZEOF_INT128__
+	using uint128 = __uint128_t;
+#else
+	struct uint128
+	{
+		uint64_t lo = 0;
+		uint64_t hi = 0;
+
+		uint128(uint64_t lo) : lo(lo) {}

-	inline s256 u2s(u256 _u)
+		uint128 operator+(uint128 a)
 		{
-		static const bigint c_end = (bigint)1 << 256;
-		static const u256 c_send = (u256)1 << 255;
-		if (_u < c_send)
-			return (s256)_u;
-		else
-			return (s256)-(c_end - _u);
+			uint128 r = 0;
+			bool overflow = lo > std::numeric_limits<uint64_t>::max() - a.lo;
+			r.lo = lo + a.lo;
+			r.hi = hi + a.hi + overflow;
+			return r;
 		}

-	inline u256 s2u(s256 _u)
+		uint128 operator>>(int s)
 		{
-		static const bigint c_end = (bigint)1 << 256;
-		if (_u >= 0)
-			return (u256)_u;
-		else
-			return (u256)(c_end + _u);
+			assert(s == 64);
+			return hi;
 		}
-}

-}
-}
-}
-
-
-extern "C"
-{
+		uint128 operator<<(int s)
+		{
+			assert(s == 64);
+			uint128 r = 0;
+			r.hi = lo;
+			return r;
+		}

-	using namespace dev::eth::jit;
+		explicit operator uint64_t() { return lo; }

-	EXPORT void arith_mul(i256* _arg1, i256* _arg2, i256* o_result)
+		static uint128 mul(uint64_t a, uint64_t b)
 		{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		*o_result = eth2llvm(arg1 * arg2);
+			auto x_lo = 0xFFFFFFFF & a;
+			auto y_lo = 0xFFFFFFFF & b;
+			auto x_hi = a >> 32;
+			auto y_hi = b >> 32;
+
+			auto t1 = x_lo * y_lo;
+			auto t2 = x_lo * y_hi;
+			auto t3 = x_hi * y_lo;
+			auto t4 = x_hi * y_hi;
+
+			auto lo = (uint32_t)t1;
+			auto mid = (uint64_t)(t1 >> 32) + (uint32_t)t2 + (uint32_t)t3;
+			auto hi = (uint64_t)(t2 >> 32) + (t3 >> 32) + t4 + (mid >> 32);
+
+			uint128 r = 0;
+			r.lo = (uint64_t)lo + (mid << 32);
+			r.hi = hi;
+			return r;
 		}

-	EXPORT void arith_div(i256* _arg1, i256* _arg2, i256* o_result)
+		uint128 operator*(uint128 a)
 		{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		*o_result = eth2llvm(arg2 == 0 ? arg2 : arg1 / arg2);
+			auto t1 = mul(lo, a.lo);
+			auto t2 = mul(lo, a.hi);
+			auto t3 = mul(hi, a.lo);
+			return t1 + (t2 << 64) + (t3 << 64);
 		}
+	};
+#endif

-	EXPORT void arith_mod(i256* _arg1, i256* _arg2, i256* o_result)
+	struct uint256
 	{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		*o_result = eth2llvm(arg2 == 0 ? arg2 : arg1 % arg2);
+		uint64_t lo = 0;
+		uint64_t mid = 0;
+		uint128 hi = 0;
+
+		uint256(uint64_t lo, uint64_t mid, uint128 hi): lo(lo), mid(mid), hi(hi) {}
+		uint256(uint128 n)
+		{
+			lo = (uint64_t) n;
+			mid = (uint64_t) (n >> 64);
 		}

-	EXPORT void arith_sdiv(i256* _arg1, i256* _arg2, i256* o_result)
+		explicit operator uint128()
 		{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		*o_result = eth2llvm(arg2 == 0 ? arg2 : s2u(u2s(arg1) / u2s(arg2)));
+			uint128 r = lo;
+			r |= ((uint128) mid) << 64;
+			return r;
 		}

-	EXPORT void arith_smod(i256* _arg1, i256* _arg2, i256* o_result)
+		uint256 operator+(uint256 a)
 		{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		*o_result = eth2llvm(arg2 == 0 ? arg2 : s2u(u2s(arg1) % u2s(arg2)));
+			auto _lo = (uint128) lo + a.lo;
+			auto _mid = (uint128) mid + a.mid + (_lo >> 64);
+			auto _hi = hi + a.hi + (_mid >> 64);
+			return {(uint64_t)_lo, (uint64_t)_mid, _hi};
 		}

-	EXPORT void arith_exp(i256* _arg1, i256* _arg2, i256* o_result)
+		uint256 lo2hi()
 		{
-		bigint left = llvm2eth(*_arg1);
-		bigint right = llvm2eth(*_arg2);
-		auto ret = static_cast<u256>(boost::multiprecision::powm(left, right, bigint(2) << 256));
-		*o_result = eth2llvm(ret);
+			hi = (uint128)*this;
+			lo = 0;
+			mid = 0;
+			return *this;
 		}
+	};
+
+	struct uint512
+	{
+		uint128 lo;
+		uint128 mid;
+		uint256 hi;
+	};

-	EXPORT void arith_mulmod(i256* _arg1, i256* _arg2, i256* _arg3, i256* o_result)
+	uint256 mul(uint256 x, uint256 y)
 	{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		auto arg3 = llvm2eth(*_arg3);
-		if (arg3 != 0)
-			*o_result = eth2llvm(u256((bigint(arg1) * bigint(arg2)) % arg3));
-		else
-			*o_result = {};
+		auto t1 = (uint128) x.lo * y.lo;
+		auto t2 = (uint128) x.lo * y.mid;
+		auto t3 = (uint128) x.lo * y.hi;
+		auto t4 = (uint128) x.mid * y.lo;
+		auto t5 = (uint128) x.mid * y.mid;
+		auto t6 = (uint128) x.mid * y.hi;
+		auto t7 = x.hi * y.lo;
+		auto t8 = x.hi * y.mid;
+
+		auto lo = (uint64_t) t1;
+		auto m1 = (t1 >> 64) + (uint64_t) t2;
+		auto m2 = (uint64_t) m1;
+		auto mid = (uint128) m2 + (uint64_t) t4;
+		auto hi = (t2 >> 64) + t3 + (t4 >> 64) + t5 + (t6 << 64) + t7
+			 + (t8 << 64) + (m1 >> 64) + (mid >> 64);
+
+		return {lo, (uint64_t)mid, hi};
 	}

-	EXPORT void arith_addmod(i256* _arg1, i256* _arg2, i256* _arg3, i256* o_result)
+	uint512 mul512(uint256 x, uint256 y)
 	{
-		auto arg1 = llvm2eth(*_arg1);
-		auto arg2 = llvm2eth(*_arg2);
-		auto arg3 = llvm2eth(*_arg3);
-		if (arg3 != 0)
-			*o_result = eth2llvm(u256((bigint(arg1) + bigint(arg2)) % arg3));
-		else
-			*o_result = {};
+		auto x_lo = (uint128) x;
+		auto y_lo = (uint128) y;
+
+		auto t1 = mul(x_lo, y_lo);
+		auto t2 = mul(x_lo, y.hi);
+		auto t3 = mul(x.hi, y_lo);
+		auto t4 = mul(x.hi, y.hi);
+
+		auto lo = (uint128) t1;
+		auto mid = (uint256) t1.hi + (uint128) t2 + (uint128) t3;
+		auto hi = (uint256)t2.hi + t3.hi + t4 + mid.hi;
+
+		return {lo, (uint128)mid, hi};
 	}
+}

+}
+}
 }

+extern "C"
+{
+	using namespace dev::eth::jit;

+	EXPORT void debug(uint64_t a, uint64_t b, uint64_t c, uint64_t d, char z)
+	{
+		std::cerr << "DEBUG " << z << ": " << d << c << b << a << std::endl;
+	}
+
+	EXPORT void arith_mul(uint256* _arg1, uint256* _arg2, uint256* o_result)
+	{
+		*o_result = mul(*_arg1, *_arg2);
+	}
+
+	EXPORT void arith_mul512(uint256* _arg1, uint256* _arg2, uint512* o_result)
+	{
+		*o_result = mul512(*_arg1, *_arg2);
+	}
+}
--- a/evmjit/libevmjit/Arith256.h
+++ b/evmjit/libevmjit/Arith256.h
@ -13,29 +13,32 @@ class Arith256 : public CompilerHelper
 {
 public:
 	Arith256(llvm::IRBuilder<>& _builder);
-	virtual ~Arith256();

 	llvm::Value* mul(llvm::Value* _arg1, llvm::Value* _arg2);
-	llvm::Value* div(llvm::Value* _arg1, llvm::Value* _arg2);
-	llvm::Value* mod(llvm::Value* _arg1, llvm::Value* _arg2);
-	llvm::Value* sdiv(llvm::Value* _arg1, llvm::Value* _arg2);
-	llvm::Value* smod(llvm::Value* _arg1, llvm::Value* _arg2);
+	std::pair<llvm::Value*, llvm::Value*> div(llvm::Value* _arg1, llvm::Value* _arg2);
+	std::pair<llvm::Value*, llvm::Value*> sdiv(llvm::Value* _arg1, llvm::Value* _arg2);
 	llvm::Value* exp(llvm::Value* _arg1, llvm::Value* _arg2);
 	llvm::Value* mulmod(llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3);
 	llvm::Value* addmod(llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3);

+	void debug(llvm::Value* _value, char _c);
+
 private:
+	llvm::Function* getDivFunc(llvm::Type* _type);
+	llvm::Function* getExpFunc();
+	llvm::Function* getAddModFunc();
+	llvm::Function* getMulModFunc();
+
 	llvm::Value* binaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2);
-	llvm::Value* ternaryOp(llvm::Function* _op, llvm::Value* _arg1, llvm::Value* _arg2, llvm::Value* _arg3);

 	llvm::Function* m_mul;
-	llvm::Function* m_div;
-	llvm::Function* m_mod;
-	llvm::Function* m_sdiv;
-	llvm::Function* m_smod;
-	llvm::Function* m_exp;
-	llvm::Function* m_mulmod;
-	llvm::Function* m_addmod;
+
+	llvm::Function* m_div = nullptr;
+	llvm::Function* m_div512 = nullptr;
+	llvm::Function* m_exp = nullptr;
+	llvm::Function* m_addmod = nullptr;
+	llvm::Function* m_mulmod = nullptr;
+	llvm::Function* m_debug = nullptr;

 	llvm::Value* m_arg1;
 	llvm::Value* m_arg2;
--- a/evmjit/libevmjit/CMakeLists.txt
+++ b/evmjit/libevmjit/CMakeLists.txt
@ -11,15 +11,25 @@ if (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
 	set_source_files_properties(Cache.cpp PROPERTIES COMPILE_FLAGS -fno-rtti)
 endif()

+find_package(Git)
+if(GIT_FOUND)
+	execute_process(COMMAND ${GIT_EXECUTABLE} -C ${CMAKE_CURRENT_SOURCE_DIR} describe --dirty --always
+					OUTPUT_VARIABLE EVMJIT_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE)
+endif()
+if(NOT EVMJIT_VERSION)
+	set(EVMJIT_VERSION "unknown")
+endif()
+
+message("EVM JIT version: ${EVMJIT_VERSION}")
+
 add_library(${TARGET_NAME} SHARED ${SOURCES} ${HEADERS})
-set_property(TARGET ${TARGET_NAME} PROPERTY FOLDER "libs")
+set_target_properties(${TARGET_NAME} PROPERTIES VERSION ${EVMJIT_VERSION} FOLDER "libs")

 include_directories(${LLVM_INCLUDE_DIRS})
-include_directories(${Boost_INCLUDE_DIRS})

 target_link_libraries(${TARGET_NAME} PRIVATE ${LLVM_LIBS})

 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")

-install(TARGETS ${TARGET_NAME} LIBRARY DESTINATION lib)
-install(FILES ${INTERFACE_HEADERS} DESTINATION include/${TARGET_NAME})
+install(TARGETS ${TARGET_NAME} LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin)
+#install(FILES ${INTERFACE_HEADERS} DESTINATION include/${TARGET_NAME})
--- a/evmjit/libevmjit/Common.h
+++ b/evmjit/libevmjit/Common.h
@ -1,7 +1,14 @@
 #pragma once

 #include <vector>
-#include <boost/multiprecision/cpp_int.hpp>
+#include <tuple>
+#include <cstdint>
+
+#ifdef _MSC_VER
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif

 namespace dev
 {
@ -12,8 +19,7 @@ namespace jit

 using byte = uint8_t;
 using bytes = std::vector<byte>;
-using u256 = boost::multiprecision::uint256_t;
-using bigint = boost::multiprecision::cpp_int;
+using bytes_ref = std::tuple<byte const*, size_t>;

 struct NoteChannel {};	// FIXME: Use some log library?

@ -23,18 +29,21 @@ enum class ReturnCode
 	Return = 1,
 	Suicide = 2,

-	BadJumpDestination = 101,
-	OutOfGas = 102,
-	StackTooSmall = 103,
-	BadInstruction = 104,
+	OutOfGas = -1,
+	BadJumpDestination = -2,
+	StackTooSmall = -3,
+	BadInstruction = -4,
+
+	LLVMConfigError = -5,
+	LLVMCompileError = -6,
+	LLVMLinkError = -7,
+
+	UnexpectedException = -8,

-	LLVMConfigError = 201,
-	LLVMCompileError = 202,
-	LLVMLinkError = 203,
+	LinkerWorkaround = -299,
 };

 /// Representation of 256-bit value binary compatible with LLVM i256
-// TODO: Replace with h256
 struct i256
 {
 	uint64_t a = 0;
--- a/evmjit/libevmjit/Compiler.cpp
+++ b/evmjit/libevmjit/Compiler.cpp
@ -4,6 +4,7 @@
 #include <functional>
 #include <fstream>
 #include <chrono>
+#include <sstream>

 #include <llvm/ADT/PostOrderIterator.h>
 #include <llvm/IR/CFG.h>
@ -90,6 +91,7 @@ void Compiler::createBasicBlocks(bytes const& _bytecode)
 		}
 	}

+	// TODO: Create Stop basic block on demand
 	m_stopBB = llvm::BasicBlock::Create(m_mainFunc->getContext(), "Stop", m_mainFunc);
 }

@ -272,7 +274,7 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 			auto lhs = stack.pop();
 			auto rhs = stack.pop();
 			auto res = _arith.div(lhs, rhs);
-			stack.push(res);
+			stack.push(res.first);
 			break;
 		}

@ -281,7 +283,7 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 			auto lhs = stack.pop();
 			auto rhs = stack.pop();
 			auto res = _arith.sdiv(lhs, rhs);
-			stack.push(res);
+			stack.push(res.first);
 			break;
 		}

@ -289,8 +291,8 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 		{
 			auto lhs = stack.pop();
 			auto rhs = stack.pop();
-			auto res = _arith.mod(lhs, rhs);
-			stack.push(res);
+			auto res = _arith.div(lhs, rhs);
+			stack.push(res.second);
 			break;
 		}

@ -298,8 +300,8 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 		{
 			auto lhs = stack.pop();
 			auto rhs = stack.pop();
-			auto res = _arith.smod(lhs, rhs);
-			stack.push(res);
+			auto res = _arith.sdiv(lhs, rhs);
+			stack.push(res.second);
 			break;
 		}

@ -455,14 +457,15 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode

 			// test for word >> (k * 8 + 7)
 			auto bitpos = m_builder.CreateAdd(k32x8, m_builder.getInt64(7), "bitpos");
-			auto bittester = m_builder.CreateShl(Constant::get(1), bitpos);
+			auto bitposEx = m_builder.CreateZExt(bitpos, Type::Word);
+			auto bittester = m_builder.CreateShl(Constant::get(1), bitposEx);
 			auto bitresult = m_builder.CreateAnd(word, bittester);
 			auto bittest = m_builder.CreateICmpUGT(bitresult, Constant::get(0));
 			// FIXME: The following does not work - LLVM bug, report!
 			//auto bitval = m_builder.CreateLShr(word, bitpos, "bitval");
 			//auto bittest = m_builder.CreateTrunc(bitval, Type::Bool, "bittest");

-			auto mask_ = m_builder.CreateShl(Constant::get(1), bitpos);
+			auto mask_ = m_builder.CreateShl(Constant::get(1), bitposEx);
 			auto mask = m_builder.CreateSub(mask_, Constant::get(1), "mask");

 			auto negmask = m_builder.CreateXor(mask, llvm::ConstantInt::getAllOnesValue(Type::Word), "negmask");
@ -636,20 +639,29 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 		case Instruction::CALLER:
 		case Instruction::ORIGIN:
 		case Instruction::CALLVALUE:
-		case Instruction::CALLDATASIZE:
-		case Instruction::CODESIZE:
 		case Instruction::GASPRICE:
 		case Instruction::COINBASE:
-		case Instruction::TIMESTAMP:
-		case Instruction::NUMBER:
 		case Instruction::DIFFICULTY:
 		case Instruction::GASLIMIT:
+		case Instruction::NUMBER:
+		case Instruction::TIMESTAMP:
 		{
 			// Pushes an element of runtime data on stack
-			stack.push(_runtimeManager.get(inst));
+			auto value = _runtimeManager.get(inst);
+			value = m_builder.CreateZExt(value, Type::Word);
+			stack.push(value);
 			break;
 		}

+		case Instruction::CODESIZE:
+			// TODO: Use constant
+			stack.push(_runtimeManager.getCodeSize());
+			break;
+
+		case Instruction::CALLDATASIZE:
+			stack.push(_runtimeManager.getCallDataSize());
+			break;
+
 		case Instruction::BLOCKHASH:
 		{
 			auto number = stack.pop();
@ -681,7 +693,7 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 			auto reqBytes = stack.pop();

 			auto srcPtr = _runtimeManager.getCallData();
-			auto srcSize = _runtimeManager.get(RuntimeData::CallDataSize);
+			auto srcSize = _runtimeManager.getCallDataSize();

 			_memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
 			break;
@ -694,7 +706,7 @@ void Compiler::compileBasicBlock(BasicBlock& _basicBlock, bytes const& _bytecode
 			auto reqBytes = stack.pop();

 			auto srcPtr = _runtimeManager.getCode();    // TODO: Code & its size are constants, feature #80814234
-			auto srcSize = _runtimeManager.get(RuntimeData::CodeSize);
+			auto srcSize = _runtimeManager.getCodeSize();

 			_memory.copyBytes(srcPtr, srcSize, srcIdx, destMemIdx, reqBytes);
 			break;
@ -852,6 +864,18 @@ void Compiler::removeDeadBlocks()
 		}
 	}
 	while (sthErased);
+
+	if (m_jumpTableBlock && llvm::pred_begin(m_jumpTableBlock->llvm()) == llvm::pred_end(m_jumpTableBlock->llvm()))
+	{
+		m_jumpTableBlock->llvm()->eraseFromParent();
+		m_jumpTableBlock.reset();
+	}
+
+	if (m_badJumpBlock && llvm::pred_begin(m_badJumpBlock->llvm()) == llvm::pred_end(m_badJumpBlock->llvm()))
+	{
+		m_badJumpBlock->llvm()->eraseFromParent();
+		m_badJumpBlock.reset();
+	}
 }

 void Compiler::dumpCFGifRequired(std::string const& _dotfilePath)
--- a/evmjit/libevmjit/ExecutionEngine.cpp
+++ b/evmjit/libevmjit/ExecutionEngine.cpp
@ -1,6 +1,7 @@
 #include "ExecutionEngine.h"

 #include <chrono>
+#include <cstdlib>	// env options

 #include <llvm/IR/Module.h>
 #include <llvm/ADT/Triple.h>
@ -19,13 +20,6 @@
 #include "Compiler.h"
 #include "Cache.h"

-#if defined(NDEBUG)
-#define DEBUG_ENV_OPTION(name) false
-#else
-#include <cstdlib>
-#define DEBUG_ENV_OPTION(name) (std::getenv(#name) != nullptr)
-#endif
-
 namespace dev
 {
 namespace eth
@ -67,13 +61,21 @@ std::string codeHash(bytes const& _code)
 	return std::to_string(hash);
 }

+bool getEnvOption(char const* _name, bool _default)
+{
+	auto var = std::getenv(_name);
+	if (!var)
+		return _default;
+	return std::strtol(var, nullptr, 10) != 0;
+}
+
 }

 ReturnCode ExecutionEngine::run(bytes const& _code, RuntimeData* _data, Env* _env)
 {
 	static std::unique_ptr<llvm::ExecutionEngine> ee;  // TODO: Use Managed Objects from LLVM?
-	static auto debugDumpModule = DEBUG_ENV_OPTION(EVMJIT_DUMP_MODULE);
-	static bool objectCacheEnabled = !DEBUG_ENV_OPTION(EVMJIT_CACHE_OFF);
+	static auto debugDumpModule = getEnvOption("EVMJIT_DUMP", false);
+	static auto objectCacheEnabled = getEnvOption("EVMJIT_CACHE", true);

 	auto mainFuncName = codeHash(_code);
 	EntryFuncPtr entryFuncPtr{};
@ -136,7 +138,10 @@ ReturnCode ExecutionEngine::run(bytes const& _code, RuntimeData* _data, Env* _en

 	auto returnCode = runEntryFunc(entryFuncPtr, &runtime);
 	if (returnCode == ReturnCode::Return)
-		this->returnData = runtime.getReturnData();
+	{
+		returnData = runtime.getReturnData();     // Save reference to return data
+		std::swap(m_memory, runtime.getMemory()); // Take ownership of memory
+	}

 	auto executionEndTime = std::chrono::high_resolution_clock::now();
 	clog(JIT) << " + " << std::chrono::duration_cast<std::chrono::milliseconds>(executionEndTime - executionStartTime).count() << " ms\n";
--- a/evmjit/libevmjit/ExecutionEngine.h
+++ b/evmjit/libevmjit/ExecutionEngine.h
@ -16,9 +16,15 @@ public:
 	ExecutionEngine(ExecutionEngine const&) = delete;
 	void operator=(ExecutionEngine) = delete;

-	ReturnCode run(bytes const& _code, RuntimeData* _data, Env* _env);
+	EXPORT ReturnCode run(bytes const& _code, RuntimeData* _data, Env* _env);

-	bytes returnData;
+	/// Reference to returned data (RETURN opcode used)
+	bytes_ref returnData;
+
+private:
+	/// After execution, if RETURN used, memory is moved there
+	/// to allow client copy the returned data
+	bytes m_memory;
 };

 }
--- a/evmjit/libevmjit/Memory.cpp
+++ b/evmjit/libevmjit/Memory.cpp
@ -176,7 +176,8 @@ llvm::Value* Memory::getSize()

 llvm::Value* Memory::getBytePtr(llvm::Value* _index)
 {
-	return m_builder.CreateGEP(getData(), _index, "ptr");
+	auto idx = m_builder.CreateTrunc(_index, Type::Size, "idx"); // Never allow memory index be a type bigger than i64
+	return m_builder.CreateGEP(getData(), idx, "ptr");
 }

 void Memory::require(llvm::Value* _offset, llvm::Value* _size)
@ -214,7 +215,8 @@ void Memory::copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value*
 	auto bytesToCopy = m_builder.CreateSelect(isOutsideData, zero64, bytesToCopyInner);

 	auto src = m_builder.CreateGEP(_srcPtr, idx64, "src");
-	auto dst = m_builder.CreateGEP(getData(), _destMemIdx, "dst");
+	auto dstIdx = m_builder.CreateTrunc(_destMemIdx, Type::Size, "dstIdx"); // Never allow memory index be a type bigger than i64
+	auto dst = m_builder.CreateGEP(getData(), dstIdx, "dst");
 	m_builder.CreateMemCpy(dst, src, bytesToCopy, 0);
 }

--- a/evmjit/libevmjit/Runtime.cpp
+++ b/evmjit/libevmjit/Runtime.cpp
@ -18,18 +18,19 @@ Runtime::Runtime(RuntimeData* _data, Env* _env) :
 	m_currJmpBuf(m_jmpBuf)
 {}

-bytes Runtime::getReturnData() const	// FIXME: Reconsider returning by copy
+bytes_ref Runtime::getReturnData() const
 {
-	// TODO: Handle large indexes
-	auto offset = static_cast<size_t>(llvm2eth(m_data.elems[RuntimeData::ReturnDataOffset]));
-	auto size = static_cast<size_t>(llvm2eth(m_data.elems[RuntimeData::ReturnDataSize]));
+	auto data = m_data.callData;
+	auto size = static_cast<size_t>(m_data.callDataSize);

-	assert(offset + size <= m_memory.size() || size == 0);
-	if (offset + size > m_memory.size())
+	if (data < m_memory.data() || data >= m_memory.data() + m_memory.size() || size == 0)
+	{
+		assert(size == 0); // data can be an invalid pointer only if size is 0
+		m_data.callData = nullptr;
 		return {};
+	}

-	auto dataBeg = m_memory.begin() + offset;
-	return {dataBeg, dataBeg + size};
+	return bytes_ref{data, size};
 }

 }
--- a/evmjit/libevmjit/Runtime.h
+++ b/evmjit/libevmjit/Runtime.h
@ -2,21 +2,8 @@
 #pragma once

 #include <csetjmp>
-#include <vector>
-
-#include "Instruction.h"
-#include "CompilerHelper.h"
-#include "Utils.h"
-#include "Type.h"
 #include "RuntimeData.h"

-
-#ifdef _MSC_VER
-	#define EXPORT __declspec(dllexport)
-#else
-	#define EXPORT
-#endif
-
 namespace dev
 {
 namespace eth
@ -40,7 +27,7 @@ public:
 	MemoryImpl& getMemory() { return m_memory; }
 	Env* getEnvPtr() { return &m_env; }

-	bytes getReturnData() const;
+	bytes_ref getReturnData() const;
 	jmp_buf_ref getJmpBuf() { return m_jmpBuf; }

 private:
--- a/evmjit/libevmjit/RuntimeData.h
+++ b/evmjit/libevmjit/RuntimeData.h
@ -15,32 +15,41 @@ struct RuntimeData
 	enum Index
 	{
 		Gas,
+		GasPrice,
+		CallData,
+		CallDataSize,
 		Address,
 		Caller,
 		Origin,
 		CallValue,
-		CallDataSize,
-		GasPrice,
 		CoinBase,
-		TimeStamp,
-		Number,
 		Difficulty,
 		GasLimit,
+		Number,
+		Timestamp,
+		Code,
 		CodeSize,

-		_size,
-
-		ReturnDataOffset = CallValue,	// Reuse 2 fields for return data reference
-		ReturnDataSize = CallDataSize,
 		SuicideDestAddress = Address,		///< Suicide balance destination address
+		ReturnData 		   = CallData,		///< Return data pointer (set only in case of RETURN)
+		ReturnDataSize 	   = CallDataSize,	///< Return data size (set only in case of RETURN)
 	};

-	i256 elems[_size] = {};
+	int64_t 	gas = 0;
+	int64_t 	gasPrice = 0;
 	byte const* callData = nullptr;
+	uint64_t 	callDataSize = 0;
+	i256 		address;
+	i256 		caller;
+	i256 		origin;
+	i256 		callValue;
+	i256 		coinBase;
+	i256 		difficulty;
+	i256 		gasLimit;
+	uint64_t 	number = 0;
+	int64_t 	timestamp = 0;
 	byte const* code = nullptr;
-
-	void set(Index _index, u256 _value) { elems[_index] = eth2llvm(_value); }
-	u256 get(Index _index) { return llvm2eth(elems[_index]); }
+	uint64_t 	codeSize = 0;
 };

 /// VM Environment (ExtVM) opaque type
--- a/evmjit/libevmjit/RuntimeManager.cpp
+++ b/evmjit/libevmjit/RuntimeManager.cpp
@ -22,9 +22,21 @@ llvm::StructType* RuntimeManager::getRuntimeDataType()
 	{
 		llvm::Type* elems[] =
 		{
-			llvm::ArrayType::get(Type::Word, RuntimeData::_size),	// i256[]
+			Type::Size,		// gas
+			Type::Size,		// gasPrice
 			Type::BytePtr,	// callData
-			Type::BytePtr		// code
+			Type::Size,		// callDataSize
+			Type::Word,		// address
+			Type::Word,		// caller
+			Type::Word,		// origin
+			Type::Word,		// callValue
+			Type::Word,		// coinBase
+			Type::Word,		// difficulty
+			Type::Word,		// gasLimit
+			Type::Size,		// blockNumber
+			Type::Size,		// blockTimestamp
+			Type::BytePtr,	// code
+			Type::Size,		// codeSize
 		};
 		type = llvm::StructType::create(elems, "RuntimeData");
 	}
@ -56,19 +68,21 @@ llvm::Twine getName(RuntimeData::Index _index)
 	switch (_index)
 	{
 	default:						return "data";
-	case RuntimeData::Gas:			return "gas";
 	case RuntimeData::Address:		return "address";
 	case RuntimeData::Caller:		return "caller";
 	case RuntimeData::Origin:		return "origin";
 	case RuntimeData::CallValue:	return "callvalue";
-	case RuntimeData::CallDataSize:	return "calldatasize";
 	case RuntimeData::GasPrice:		return "gasprice";
 	case RuntimeData::CoinBase:		return "coinbase";
-	case RuntimeData::TimeStamp:	return "timestamp";
-	case RuntimeData::Number:		return "number";
 	case RuntimeData::Difficulty:	return "difficulty";
 	case RuntimeData::GasLimit:		return "gaslimit";
-	case RuntimeData::CodeSize:		return "codesize";
+	case RuntimeData::CallData:		return "callData";
+	case RuntimeData::Code:			return "code";
+	case RuntimeData::CodeSize:		return "code";
+	case RuntimeData::CallDataSize:	return "callDataSize";
+	case RuntimeData::Gas:			return "gas";
+	case RuntimeData::Number:	return "number";
+	case RuntimeData::Timestamp:	return "timestamp";
 	}
 }
 }
@ -100,7 +114,9 @@ llvm::Value* RuntimeManager::getDataPtr()
 		return m_dataPtr;

 	auto rtPtr = getRuntimePtr();
-	return m_builder.CreateLoad(m_builder.CreateStructGEP(rtPtr, 0), "data");
+	auto dataPtr = m_builder.CreateLoad(m_builder.CreateStructGEP(rtPtr, 0), "data");
+	assert(dataPtr->getType() == getRuntimeDataType()->getPointerTo());
+	return dataPtr;
 }

 llvm::Value* RuntimeManager::getEnvPtr()
@ -111,24 +127,33 @@ llvm::Value* RuntimeManager::getEnvPtr()

 llvm::Value* RuntimeManager::getPtr(RuntimeData::Index _index)
 {
-	llvm::Value* idxList[] = {m_builder.getInt32(0), m_builder.getInt32(0), m_builder.getInt32(_index)};
-	return m_builder.CreateInBoundsGEP(getDataPtr(), idxList, getName(_index) + "Ptr");
+	auto ptr = getBuilder().CreateStructGEP(getDataPtr(), _index);
+	assert(getRuntimeDataType()->getElementType(_index)->getPointerTo() == ptr->getType());
+	return ptr;
 }

 llvm::Value* RuntimeManager::get(RuntimeData::Index _index)
 {
-	return m_builder.CreateLoad(getPtr(_index), getName(_index));
+	return getBuilder().CreateLoad(getPtr(_index), getName(_index));
 }

 void RuntimeManager::set(RuntimeData::Index _index, llvm::Value* _value)
 {
-	m_builder.CreateStore(_value, getPtr(_index));
+	auto ptr = getPtr(_index);
+	assert(ptr->getType() == _value->getType()->getPointerTo());
+	getBuilder().CreateStore(_value, ptr);
 }

 void RuntimeManager::registerReturnData(llvm::Value* _offset, llvm::Value* _size)
 {
-	set(RuntimeData::ReturnDataOffset, _offset);
-	set(RuntimeData::ReturnDataSize, _size);
+	auto memPtr = getBuilder().CreateStructGEP(getRuntimePtr(), 3);
+	auto mem = getBuilder().CreateLoad(memPtr, "memory");
+	auto idx = m_builder.CreateTrunc(_offset, Type::Size, "idx"); // Never allow memory index be a type bigger than i64 // TODO: Report bug & fix to LLVM
+	auto returnDataPtr = getBuilder().CreateGEP(mem, idx);
+	set(RuntimeData::ReturnData, returnDataPtr);
+
+	auto size64 = getBuilder().CreateTrunc(_size, Type::Size);
+	set(RuntimeData::ReturnDataSize, size64);
 }

 void RuntimeManager::registerSuicide(llvm::Value* _balanceAddress)
@ -146,32 +171,41 @@ llvm::Value* RuntimeManager::get(Instruction _inst)
 	switch (_inst)
 	{
 	default: assert(false); return nullptr;
-	case Instruction::GAS:			return get(RuntimeData::Gas);
 	case Instruction::ADDRESS:		return get(RuntimeData::Address);
 	case Instruction::CALLER:		return get(RuntimeData::Caller);
 	case Instruction::ORIGIN:		return get(RuntimeData::Origin);
 	case Instruction::CALLVALUE:	return get(RuntimeData::CallValue);
-	case Instruction::CALLDATASIZE:	return get(RuntimeData::CallDataSize);
 	case Instruction::GASPRICE:		return get(RuntimeData::GasPrice);
 	case Instruction::COINBASE:		return get(RuntimeData::CoinBase);
-	case Instruction::TIMESTAMP:	return get(RuntimeData::TimeStamp);
-	case Instruction::NUMBER:		return get(RuntimeData::Number);
 	case Instruction::DIFFICULTY:	return get(RuntimeData::Difficulty);
 	case Instruction::GASLIMIT:		return get(RuntimeData::GasLimit);
-	case Instruction::CODESIZE:		return get(RuntimeData::CodeSize);
+	case Instruction::NUMBER:		return get(RuntimeData::Number);
+	case Instruction::TIMESTAMP:	return get(RuntimeData::Timestamp);
 	}
 }

 llvm::Value* RuntimeManager::getCallData()
 {
-	auto ptr = getBuilder().CreateStructGEP(getDataPtr(), 1, "calldataPtr");
-	return getBuilder().CreateLoad(ptr, "calldata");
+	return get(RuntimeData::CallData);
 }

 llvm::Value* RuntimeManager::getCode()
 {
-	auto ptr = getBuilder().CreateStructGEP(getDataPtr(), 2, "codePtr");
-	return getBuilder().CreateLoad(ptr, "code");
+	return get(RuntimeData::Code);
+}
+
+llvm::Value* RuntimeManager::getCodeSize()
+{
+	auto value = get(RuntimeData::CodeSize);
+	assert(value->getType() == Type::Size);
+	return getBuilder().CreateZExt(value, Type::Word);
+}
+
+llvm::Value* RuntimeManager::getCallDataSize()
+{
+	auto value = get(RuntimeData::CallDataSize);
+	assert(value->getType() == Type::Size);
+	return getBuilder().CreateZExt(value, Type::Word);
 }

 llvm::Value* RuntimeManager::getJmpBuf()
@ -182,14 +216,15 @@ llvm::Value* RuntimeManager::getJmpBuf()

 llvm::Value* RuntimeManager::getGas()
 {
-	return get(RuntimeData::Gas);
+	auto value = get(RuntimeData::Gas);
+	assert(value->getType() == Type::Size);
+	return getBuilder().CreateZExt(value, Type::Word);
 }

 void RuntimeManager::setGas(llvm::Value* _gas)
 {
-	llvm::Value* idxList[] = {m_builder.getInt32(0), m_builder.getInt32(0), m_builder.getInt32(RuntimeData::Gas)};
-	auto ptr = m_builder.CreateInBoundsGEP(getDataPtr(), idxList, "gasPtr");
-	m_builder.CreateStore(_gas, ptr);
+	auto newGas = getBuilder().CreateTrunc(_gas, Type::Size);
+	set(RuntimeData::Gas, newGas);
 }

 }
--- a/evmjit/libevmjit/RuntimeManager.h
+++ b/evmjit/libevmjit/RuntimeManager.h
@ -26,6 +26,8 @@ public:
 	llvm::Value* getGas();	// TODO: Remove
 	llvm::Value* getCallData();
 	llvm::Value* getCode();
+	llvm::Value* getCodeSize();
+	llvm::Value* getCallDataSize();
 	void setGas(llvm::Value* _gas);

 	void registerReturnData(llvm::Value* _index, llvm::Value* _size);
--- a/evmjit/libevmjit/Stack.cpp
+++ b/evmjit/libevmjit/Stack.cpp
@ -73,7 +73,7 @@ extern "C"
 	{
 		auto& stack = _rt->getStack();
 		if (stack.size() < _count)
-			longjmp(_rt->getJmpBuf(), static_cast<uint64_t>(ReturnCode::StackTooSmall));
+			longjmp(_rt->getJmpBuf(), static_cast<int>(ReturnCode::StackTooSmall));

 		stack.erase(stack.end() - _count, stack.end());
 	}
@ -92,7 +92,7 @@ extern "C"
 		auto& stack = _rt->getStack();
 		// TODO: encode _index and stack size in the return code
 		if (stack.size() <= _index)
-			longjmp(_rt->getJmpBuf(), static_cast<uint64_t>(ReturnCode::StackTooSmall));
+			longjmp(_rt->getJmpBuf(), static_cast<int>(ReturnCode::StackTooSmall));

 		*o_ret = *(stack.rbegin() + _index);
 	}
@ -102,7 +102,7 @@ extern "C"
 		auto& stack = _rt->getStack();
 		// TODO: encode _index and stack size in the return code
 		if (stack.size() <= _index)
-			longjmp(_rt->getJmpBuf(), static_cast<uint64_t>(ReturnCode::StackTooSmall));
+			longjmp(_rt->getJmpBuf(), static_cast<int>(ReturnCode::StackTooSmall));

 		*(stack.rbegin() + _index) = *_word;
 	}
@ -116,7 +116,7 @@ extern "C"
 			index = std::numeric_limits<decltype(index)>::max(); // set max to fill with 0 leter

 		auto data = _rtData->callData;
-		auto size = _rtData->elems[RuntimeData::CallDataSize].a;
+		auto size = _rtData->callDataSize;
 		for (auto i = 0; i < 32; ++i)
 		{
 			if (index < size)
--- a/evmjit/libevmjit/Utils.cpp
+++ b/evmjit/libevmjit/Utils.cpp
@ -8,32 +8,6 @@ namespace eth
 namespace jit
 {

-u256 llvm2eth(i256 _i)
-{
-	u256 u = 0;
-	u |= _i.d;
-	u <<= 64;
-	u |= _i.c;
-	u <<= 64;
-	u |= _i.b;
-	u <<= 64;
-	u |= _i.a;
-	return u;
-}
-
-i256 eth2llvm(u256 _u)
-{
-	i256 i;
-	u256 mask = 0xFFFFFFFFFFFFFFFF;
-	i.a = static_cast<uint64_t>(_u & mask);
-	_u >>= 64;
-	i.b = static_cast<uint64_t>(_u & mask);
-	_u >>= 64;
-	i.c = static_cast<uint64_t>(_u & mask);
-	_u >>= 64;
-	i.d = static_cast<uint64_t>(_u & mask);
-	return i;
-}

 }
 }
--- a/evmjit/libevmjit/Utils.h
+++ b/evmjit/libevmjit/Utils.h
@ -14,9 +14,6 @@ struct JIT: public NoteChannel  { static const char* name() { return "JIT"; } };
 //#define clog(CHANNEL) std::cerr
 #define clog(CHANNEL) std::ostream(nullptr)

-u256 llvm2eth(i256);
-i256 eth2llvm(u256);
-
 }
 }
 }
--- a/evmjit/libevmjit/interface.cpp
+++ b/evmjit/libevmjit/interface.cpp
@ -1,34 +1,41 @@
-#include "interface.h"
-#include <cstdio>
 #include "ExecutionEngine.h"

 extern "C"
 {

-evmjit_result evmjit_run(void* _data, void* _env)
-{
-	using namespace dev::eth::jit;
+using namespace dev::eth::jit;

-	auto data = static_cast<RuntimeData*>(_data);
+#ifdef _MSC_VER
+#define _ALLOW_KEYWORD_MACROS
+#define noexcept throw()
+#endif

-	ExecutionEngine engine;
+EXPORT void* evmjit_create() noexcept
+{
+	return new(std::nothrow) ExecutionEngine;
+}
+
+EXPORT void evmjit_destroy(ExecutionEngine* _engine) noexcept
+{
+	delete _engine;
+}

-	auto codePtr = data->code;
-	auto codeSize = data->elems[RuntimeData::CodeSize].a;
+EXPORT int evmjit_run(ExecutionEngine* _engine, RuntimeData* _data, Env* _env) noexcept
+{
+	try
+	{
+		auto codePtr = _data->code;
+		auto codeSize = _data->codeSize;
 		bytes bytecode;
 		bytecode.insert(bytecode.end(), codePtr, codePtr + codeSize);

-	auto returnCode = engine.run(bytecode, data, static_cast<Env*>(_env));
-	evmjit_result result = {static_cast<int32_t>(returnCode), 0, nullptr};
-	if (returnCode == ReturnCode::Return && !engine.returnData.empty())
+		auto returnCode = _engine->run(bytecode, _data, _env);
+		return static_cast<int>(returnCode);
+	}
+	catch(...)
 	{
-		// TODO: Optimized returning data. Allocating memory on client side by callback function might be a good idea
-		result.returnDataSize = engine.returnData.size();
-		result.returnData = std::malloc(result.returnDataSize);
-		std::memcpy(result.returnData, engine.returnData.data(), result.returnDataSize);
+		return static_cast<int>(ReturnCode::UnexpectedException);
 	}
-
-	return result;
 }

 }
--- a/evmjit/libevmjit/interface.h
+++ b/evmjit/libevmjit/interface.h
@ -1,53 +1,12 @@
-#include <stddef.h>
-#include <stdint.h>

 #ifdef __cplusplus
 extern "C" {
 #endif

-typedef struct evmjit_result
-{
-	int32_t  returnCode;
-	uint64_t returnDataSize;
-	void*    returnData;
+void* evmjit_create();
+int   evmjit_run(void* _jit, void* _data, void* _env);
+void  evmjit_destroy(void* _jit);

-} evmjit_result;
-
-evmjit_result evmjit_run(void* _data, void* _env);
-
-// JIT object opaque type
-typedef struct evm_jit evm_jit;
-
-// Contract execution return code
-typedef int evm_jit_return_code;
-
-// Host-endian 256-bit integer type
-typedef struct i256 i256;
-
-struct i256
-{
-	char b[33];
-};
-
-// Big-endian right aligned 256-bit hash
-typedef struct h256 h256;
-
-// Runtime data struct - must be provided by external language (Go, C++, Python)
-typedef struct evm_jit_rt evm_jit_rt;
-
-// Runtime callback functions  - implementations must be provided by external language (Go, C++, Python)
-void evm_jit_rt_sload(evm_jit_rt* _rt, i256* _index, i256* _ret);
-void evm_jit_rt_sstore(evm_jit_rt* _rt, i256* _index, i256* _value);
-void evm_jit_rt_balance(evm_jit_rt* _rt, h256* _address, i256* _ret);
-// And so on...
-
-evm_jit* evm_jit_create(evm_jit_rt* _runtime_data);
-
-evm_jit_return_code evm_jit_execute(evm_jit* _jit);
-
-void evm_jit_get_return_data(evm_jit* _jit, char* _return_data_offset, size_t* _return_data_size);
-
-void evm_jit_destroy(evm_jit* _jit);

 #ifdef __cplusplus
 }
--- a/libdevcore/CMakeLists.txt
+++ b/libdevcore/CMakeLists.txt
@ -26,9 +26,8 @@ else()
 endif()

 target_link_libraries(${EXECUTABLE} ${Boost_THREAD_LIBRARIES})
-target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARIES})
+#target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARIES})
 target_link_libraries(${EXECUTABLE} ${Boost_SYSTEM_LIBRARIES})
-target_link_libraries(${EXECUTABLE} ${Boost_CHRONO_LIBRARIES})

 if (APPLE)
 	find_package(Threads REQUIRED)
--- a/libdevcore/CommonData.h
+++ b/libdevcore/CommonData.h
@ -246,4 +246,13 @@ inline std::set<_T> operator+(std::set<_T> const& _a, std::set<_T> const& _b)
 /// Make normal string from fixed-length string.
 std::string toString(string32 const& _s);

+template<class T, class U>
+std::vector<T> keysOf(std::map<T, U> const& _m)
+{
+	std::vector<T> ret;
+	for (auto const& i: _m)
+		ret.push_back(i.first);
+	return ret;
+}
+
 }
--- a/libethereum/Client.cpp
+++ b/libethereum/Client.cpp
@ -182,7 +182,7 @@ unsigned Client::installWatch(h256 _h)
 		Guard l(m_filterLock);
 		ret = m_watches.size() ? m_watches.rbegin()->first + 1 : 0;
 		m_watches[ret] = ClientWatch(_h);
-		cwatch << "+++" << ret << _h;
+		cwatch << "+++" << ret << _h.abridged();
 	}
 	auto ch = logs(ret);
 	if (ch.empty())
@ -200,8 +200,11 @@ unsigned Client::installWatch(LogFilter const& _f)
 	{
 		Guard l(m_filterLock);
 		if (!m_filters.count(h))
+		{
+			cwatch << "FFF" << _f << h.abridged();
 			m_filters.insert(make_pair(h, _f));
 		}
+	}
 	return installWatch(h);
 }

@ -220,13 +223,17 @@ void Client::uninstallWatch(unsigned _i)
 	auto fit = m_filters.find(id);
 	if (fit != m_filters.end())
 		if (!--fit->second.refCount)
+		{
+			cwatch << "*X*" << fit->first << ":" << fit->second.filter;
 			m_filters.erase(fit);
+		}
 }

 void Client::noteChanged(h256Set const& _filters)
 {
 	Guard l(m_filterLock);
-//	cnote << "noteChanged(" << _filters << ")";
+	if (_filters.size())
+		cnote << "noteChanged(" << _filters << ")";
 	// accrue all changes left in each filter into the watches.
 	for (auto& i: m_watches)
 		if (_filters.count(i.second.id))
@ -247,8 +254,11 @@ LocalisedLogEntries Client::peekWatch(unsigned _watchId) const
 	Guard l(m_filterLock);

 	try {
-		return m_watches.at(_watchId).changes;
+		auto& w = m_watches.at(_watchId);
+		w.lastPoll = chrono::system_clock::now();
+		return w.changes;
 	} catch (...) {}
+
 	return LocalisedLogEntries();
 }

@ -258,7 +268,9 @@ LocalisedLogEntries Client::checkWatch(unsigned _watchId)
 	LocalisedLogEntries ret;

 	try {
-		std::swap(ret, m_watches.at(_watchId).changes);
+		auto& w = m_watches.at(_watchId);
+		std::swap(ret, w.changes);
+		w.lastPoll = chrono::system_clock::now();
 	} catch (...) {}

 	return ret;
@ -553,6 +565,23 @@ void Client::doWork()
 	cworkout << "WORK";

 	this_thread::sleep_for(chrono::milliseconds(100));
+	if (chrono::system_clock::now() - m_lastGarbageCollection > chrono::seconds(5))
+	{
+		// garbage collect on watches
+		vector<unsigned> toUninstall;
+		{
+			Guard l(m_filterLock);
+			for (auto key: keysOf(m_watches))
+				if (chrono::system_clock::now() - m_watches[key].lastPoll > chrono::seconds(20))
+				{
+					toUninstall.push_back(key);
+					cnote << "GC: Uninstall" << key << "(" << chrono::duration_cast<chrono::seconds>(chrono::system_clock::now() - m_watches[key].lastPoll).count() << "s old)";
+				}
+		}
+		for (auto i: toUninstall)
+			uninstallWatch(i);
+		m_lastGarbageCollection = chrono::system_clock::now();
+	}
 }

 unsigned Client::numberOf(int _n) const
--- a/libethereum/Client.h
+++ b/libethereum/Client.h
@ -89,11 +89,12 @@ static const LocalisedLogEntry InitialChange(SpecialLogEntry, 0);

 struct ClientWatch
 {
-	ClientWatch() {}
-	explicit ClientWatch(h256 _id): id(_id) {}
+	ClientWatch(): lastPoll(std::chrono::system_clock::now()) {}
+	explicit ClientWatch(h256 _id): id(_id), lastPoll(std::chrono::system_clock::now()) {}

 	h256 id;
 	LocalisedLogEntries changes = LocalisedLogEntries{ InitialChange };
+	mutable std::chrono::system_clock::time_point lastPoll = std::chrono::system_clock::now();
 };

 struct WatchChannel: public LogChannel { static const char* name() { return "(o)"; } static const int verbosity = 7; };
@ -328,6 +329,8 @@ private:
 	mutable std::mutex m_filterLock;
 	std::map<h256, InstalledFilter> m_filters;
 	std::map<unsigned, ClientWatch> m_watches;
+
+	mutable std::chrono::system_clock::time_point m_lastGarbageCollection;
 };

 }
--- a/libethereum/LogFilter.cpp
+++ b/libethereum/LogFilter.cpp
@ -27,6 +27,13 @@ using namespace std;
 using namespace dev;
 using namespace dev::eth;

+std::ostream& dev::eth::operator<<(std::ostream& _out, LogFilter const& _s)
+{
+	// TODO
+	_out << "(@" << _s.m_addresses << "#" << _s.m_topics << ">" << _s.m_earliest << "-" << _s.m_latest << "< +" << _s.m_skip << "^" << _s.m_max << ")";
+	return _out;
+}
+
 void LogFilter::streamRLP(RLPStream& _s) const
 {
 	_s.appendList(6) << m_addresses << m_topics << m_earliest << m_latest << m_max << m_skip;
--- a/libethereum/LogFilter.h
+++ b/libethereum/LogFilter.h
@ -28,9 +28,18 @@

 namespace dev
 {
+
+namespace eth
+{
+class LogFilter;
+}
+
 namespace eth
 {

+/// Simple stream output for the StateDiff.
+std::ostream& operator<<(std::ostream& _out, dev::eth::LogFilter const& _s);
+
 class State;

 class LogFilter
@ -56,14 +65,17 @@ public:
 	LogFilter withEarliest(int _e) { m_earliest = _e; return *this; }
 	LogFilter withLatest(int _e) { m_latest = _e; return *this; }

+	friend std::ostream& dev::eth::operator<<(std::ostream& _out, dev::eth::LogFilter const& _s);
+
 private:
 	AddressSet m_addresses;
 	std::array<h256Set, 4> m_topics;
 	int m_earliest = 0;
 	int m_latest = -1;
-	unsigned m_max;
-	unsigned m_skip;
+	unsigned m_max = 10;
+	unsigned m_skip = 0;
 };

 }
+
 }
--- a/libjsqrc/ethereumjs/dist/ethereum.js
+++ b/libjsqrc/ethereumjs/dist/ethereum.js
@ -1043,33 +1043,16 @@ var ProviderManager = function() {

    var self = this;
    var poll = function () {
-        if (self.provider) {
-            var pollsBatch = self.polls.map(function (data) {
-                return data.data;
-            });
-
-            var payload = jsonrpc.toBatchPayload(pollsBatch);
-            var results = self.provider.send(payload);
-
-            self.polls.forEach(function (data, index) {
-                var result = results[index];
-                
-                if (!jsonrpc.isValidResponse(result)) {
-                    console.log(result);
-                    return;
-                }
+        self.polls.forEach(function (data) {
+            var result = self.send(data.data);

-                result = result.result;
-                // dont call the callback if result is not an array, or empty one
            if (!(result instanceof Array) || result.length === 0) {
                return;
            }

            data.callback(result);
-
        });

-        }
        setTimeout(poll, 1000);
    };
    poll();
--- a/libjsqrc/ethereumjs/dist/ethereum.js.map
+++ b/libjsqrc/ethereumjs/dist/ethereum.js.map
--- a/libjsqrc/ethereumjs/dist/ethereum.min.js
+++ b/libjsqrc/ethereumjs/dist/ethereum.min.js
--- a/libjsqrc/ethereumjs/lib/providermanager.js
+++ b/libjsqrc/ethereumjs/lib/providermanager.js
@ -42,33 +42,16 @@ var ProviderManager = function() {

    var self = this;
    var poll = function () {
-        if (self.provider) {
-            var pollsBatch = self.polls.map(function (data) {
-                return data.data;
-            });
-
-            var payload = jsonrpc.toBatchPayload(pollsBatch);
-            var results = self.provider.send(payload);
-
-            self.polls.forEach(function (data, index) {
-                var result = results[index];
-                
-                if (!jsonrpc.isValidResponse(result)) {
-                    console.log(result);
-                    return;
-                }
+        self.polls.forEach(function (data) {
+            var result = self.send(data.data);

-                result = result.result;
-                // dont call the callback if result is not an array, or empty one
            if (!(result instanceof Array) || result.length === 0) {
                return;
            }

            data.callback(result);
-
        });

-        }
        setTimeout(poll, 1000);
    };
    poll();
--- a/libp2p/Capability.cpp
+++ b/libp2p/Capability.cpp
@ -39,7 +39,7 @@ Capability::Capability(Session* _s, HostCapabilityFace* _h, unsigned _idOffset):

 void Capability::disable(std::string const& _problem)
 {
-	clogS(NetConnect) << "Disabling capability '" << m_host->name() << "'. Reason:" << _problem;
+	clogS(NetWarn) << "DISABLE: Disabling capability '" << m_host->name() << "'. Reason:" << _problem;
 	m_enabled = false;
 }

--- a/libp2p/Session.cpp
+++ b/libp2p/Session.cpp
@ -320,8 +320,13 @@ bool Session::interpret(RLP const& _r)
 	{
 		auto id = _r[0].toInt<unsigned>();
 		for (auto const& i: m_capabilities)
-			if (i.second->m_enabled && id >= i.second->m_idOffset && id - i.second->m_idOffset < i.second->hostCapability()->messageCount() && i.second->interpret(id - i.second->m_idOffset, _r))
+			if (id >= i.second->m_idOffset && id - i.second->m_idOffset < i.second->hostCapability()->messageCount())
+			{
+				if (i.second->m_enabled)
+					return i.second->interpret(id - i.second->m_idOffset, _r);
+				else
 					return true;
+			}
 		return false;
 	}
 	}
--- a/libserpent/util.cpp
+++ b/libserpent/util.cpp
@ -273,7 +273,7 @@ void err(std::string errtext, Metadata met) {
    std::string err = "Error (file \"" + met.file + "\", line " +
        unsignedToDecimal(met.ln + 1) + ", char " + unsignedToDecimal(met.ch) +
        "): " + errtext;
-    std::cerr << err << "\n";
+	std::cerr << err << std::endl;
    throw(err);
 }

@ -282,7 +282,7 @@ void warn(std::string errtext, Metadata met) {
    std::string err = "Warning (file \"" + met.file + "\", line " +
        unsignedToDecimal(met.ln + 1) + ", char " + unsignedToDecimal(met.ch) +
        "): " + errtext;
-    std::cerr << err << "\n";
+	std::cerr << err << std::endl;
 }

 //Bin to hex
--- a/libweb3jsonrpc/WebThreeStubServerBase.cpp
+++ b/libweb3jsonrpc/WebThreeStubServerBase.cpp
@ -31,7 +31,9 @@
 #include <libethcore/CommonJS.h>
 #include <libwhisper/Message.h>
 #include <libwhisper/WhisperHost.h>
+#ifndef _MSC_VER
 #include <libserpent/funcs.h>
+#endif
 #include "WebThreeStubServerBase.h"

 using namespace std;
@ -446,7 +448,9 @@ Json::Value WebThreeStubServerBase::eth_compilers()
 	Json::Value ret(Json::arrayValue);
 	ret.append("lll");
 	ret.append("solidity");
+#ifndef _MSC_VER
 	ret.append("serpent");
+#endif
 	return ret;
 }

@ -462,6 +466,7 @@ std::string WebThreeStubServerBase::eth_lll(std::string const& _code)
 std::string WebThreeStubServerBase::eth_serpent(std::string const& _code)
 {
 	string res;
+#ifndef _MSC_VER
 	try
 	{
 		res = toJS(dev::asBytes(::compile(_code)));
@ -474,6 +479,7 @@ std::string WebThreeStubServerBase::eth_serpent(std::string const& _code)
 	{
 		cwarn << "Uncought serpent compilation exception";
 	}
+#endif
 	return res;
 }

--- a/mix/AppContext.cpp
+++ b/mix/AppContext.cpp
@ -50,6 +50,7 @@ AppContext::AppContext(QQmlApplicationEngine* _engine)
 	m_codeModel.reset(new CodeModel(this));
 	m_clientModel.reset(new ClientModel(this));
 	m_fileIo.reset(new FileIo());
+	connect(QApplication::clipboard(), &QClipboard::dataChanged, [this] { emit clipboardChanged();});
 }

 AppContext::~AppContext()
@ -106,6 +107,12 @@ void AppContext::displayMessageDialog(QString _title, QString _message)
 	QMetaObject::invokeMethod(dialogWin, "open");
 }

+QString AppContext::clipboard() const
+{
+	QClipboard *clipboard = QApplication::clipboard();
+	return clipboard->text();
+}
+
 void AppContext::toClipboard(QString _text)
 {
 	QClipboard *clipboard = QApplication::clipboard();
--- a/mix/AppContext.h
+++ b/mix/AppContext.h
@ -48,6 +48,7 @@ class FileIo;
 class AppContext: public QObject
 {
 	Q_OBJECT
+	Q_PROPERTY(QString clipboard READ clipboard WRITE toClipboard NOTIFY clipboardChanged)

 public:
 	AppContext(QQmlApplicationEngine* _engine);
@ -64,10 +65,13 @@ public:
 	void displayMessageDialog(QString _title, QString _message);
 	/// Copy text to clipboard
 	Q_INVOKABLE void toClipboard(QString _text);
+	/// Get text from clipboard
+	QString clipboard() const;

 signals:
 	/// Triggered once components have been loaded
 	void appLoaded();
+	void clipboardChanged();

 private:
 	QQmlApplicationEngine* m_applicationEngine; //owned by app
--- a/mix/CMakeLists.txt
+++ b/mix/CMakeLists.txt
@ -46,7 +46,9 @@ target_link_libraries(${EXECUTABLE} evm)
 target_link_libraries(${EXECUTABLE} ethcore)
 target_link_libraries(${EXECUTABLE} devcrypto)
 target_link_libraries(${EXECUTABLE} secp256k1)
+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
 target_link_libraries(${EXECUTABLE} serpent)
+endif()
 target_link_libraries(${EXECUTABLE} lll)
 target_link_libraries(${EXECUTABLE} solidity)
 target_link_libraries(${EXECUTABLE} evmcore)
--- a/mix/MixClient.cpp
+++ b/mix/MixClient.cpp
@ -27,6 +27,7 @@
 #include <libethereum/Transaction.h>
 #include <libethereum/Executive.h>
 #include <libethereum/ExtVM.h>
+#include <libethereum/BlockChain.h>
 #include <libevm/VM.h>

 #include "Exceptions.h"
@ -34,15 +35,37 @@

 using namespace dev;
 using namespace dev::eth;
-using namespace dev::mix;
+
+namespace dev
+{
+namespace mix
+{

 const Secret c_userAccountSecret = Secret("cb73d9408c4720e230387d956eb0f829d8a4dd2c1055f96257167e14e7169074");
+const u256 c_mixGenesisDifficulty = (u256) 1 << 4;
+
+class MixBlockChain: public dev::eth::BlockChain
+{
+public:
+	MixBlockChain(std::string const& _path, h256 _stateRoot):  BlockChain(createGenesisBlock(_stateRoot), _path, true)
+	{
+	}
+
+	static bytes createGenesisBlock(h256 _stateRoot)
+	{
+		RLPStream block(3);
+		block.appendList(14)
+				<< h256() << EmptyListSHA3 << h160() << _stateRoot << EmptyTrie << EmptyTrie << LogBloom() << c_mixGenesisDifficulty << 0 << 1000000 << 0 << (unsigned)0 << std::string() << sha3(bytes(1, 42));
+		block.appendRaw(RLPEmptyList);
+		block.appendRaw(RLPEmptyList);
+		return block.out();
+	}
+};

 MixClient::MixClient(std::string const& _dbPath):
-	m_userAccount(c_userAccountSecret), m_bc(_dbPath, true), m_dbPath(_dbPath), m_minigThreads(0)
+	m_userAccount(c_userAccountSecret), m_dbPath(_dbPath), m_minigThreads(0)
 {
-	//TODO: put this into genesis block somehow
-	//resetState(10000000 * ether);
+	resetState(10000000 * ether);
 }

 MixClient::~MixClient()
@ -51,21 +74,23 @@ MixClient::~MixClient()

 void MixClient::resetState(u256 _balance)
 {
-	(void) _balance;
-	{
 	WriteGuard l(x_state);
 	Guard fl(m_filterLock);
 	m_filters.clear();
 	m_watches.clear();
-		m_bc.reopen(m_dbPath, true);
-		m_state = eth::State();
+
 	m_stateDB = OverlayDB();
-		m_state = eth::State(m_userAccount.address(), m_stateDB, BaseState::CanonGenesis);
-		m_state.sync(m_bc);
+	TrieDB<Address, MemoryDB> accountState(&m_stateDB);
+	accountState.init();
+	std::map<Address, Account> genesisState = { std::make_pair(KeyPair(c_userAccountSecret).address(), Account(_balance, Account::NormalCreation)) };
+	dev::eth::commit(genesisState, static_cast<MemoryDB&>(m_stateDB), accountState);
+	h256 stateRoot = accountState.root();
+	m_bc.reset();
+	m_bc.reset(new MixBlockChain(m_dbPath, stateRoot));
+	m_state = eth::State(m_userAccount.address(), m_stateDB, BaseState::Empty);
+	m_state.sync(bc());
 	m_startState = m_state;
 	m_pendingExecutions.clear();
-	}
-	mine();
 }

 void MixClient::executeTransaction(Transaction const& _t, State& _state)
@ -74,9 +99,9 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state)

 	// do debugging run first
 	LastHashes lastHashes(256);
-	lastHashes[0] = m_bc.numberHash(m_bc.number());
+	lastHashes[0] = bc().numberHash(bc().number());
 	for (unsigned i = 1; i < 256; ++i)
-		lastHashes[i] = lastHashes[i - 1] ? m_bc.details(lastHashes[i - 1]).parent : h256();
+		lastHashes[i] = lastHashes[i - 1] ? bc().details(lastHashes[i - 1]).parent : h256();

 	State execState = _state;
 	Executive execution(execState, lastHashes, 0);
@ -155,7 +180,7 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state)
 	h256Set changed;
 	Guard l(m_filterLock);
 	for (std::pair<h256 const, eth::InstalledFilter>& i: m_filters)
-		if ((unsigned)i.second.filter.latest() > m_bc.number())
+		if ((unsigned)i.second.filter.latest() > bc().number())
 		{
 			// acceptable number.
 			auto m = i.second.filter.matches(_state.receipt(_state.pending().size() - 1));
@ -163,7 +188,7 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state)
 			{
 				// filter catches them
 				for (LogEntry const& l: m)
-					i.second.changes.push_back(LocalisedLogEntry(l, m_bc.number() + 1));
+					i.second.changes.push_back(LocalisedLogEntry(l, bc().number() + 1));
 				changed.insert(i.first);
 			}
 		}
@ -174,11 +199,11 @@ void MixClient::executeTransaction(Transaction const& _t, State& _state)
 void MixClient::mine()
 {
 	WriteGuard l(x_state);
-	m_state.commitToMine(m_bc);
+	m_state.commitToMine(bc());
 	while (!m_state.mine(100, true).completed) {}
 	m_state.completeMine();
-	m_bc.import(m_state.blockData(), m_stateDB);
-	m_state.sync(m_bc);
+	bc().import(m_state.blockData(), m_stateDB);
+	m_state.sync(bc());
 	//m_state.cleanup(true);
 	m_startState = m_state;
 	m_executions.emplace_back(std::move(m_pendingExecutions));
@ -188,7 +213,7 @@ void MixClient::mine()

 ExecutionResult const& MixClient::execution(unsigned _block, unsigned _transaction) const
 {
-	if (_block == m_bc.number() + 1)
+	if (_block == bc().number() + 1)
 		return m_pendingExecutions.at(_transaction);
 	return m_executions.at(_block).at(_transaction);
 }
@ -213,14 +238,13 @@ State MixClient::asOf(int _block) const
 	else if (_block == -1)
 		return m_startState;
 	else
-		return State(m_stateDB, m_bc, m_bc.numberHash(_block));
+		return State(m_stateDB, bc(), bc().numberHash(_block));
 }

 void MixClient::transact(Secret _secret, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice)
 {
 	WriteGuard l(x_state);
 	u256 n = m_state.transactionsFrom(toAddress(_secret));
-	_gasPrice = 0; //TODO: remove after fixing setBalance
 	Transaction t(_value, _gasPrice, _gas, _dest, _data, n, _secret);
 	executeTransaction(t, m_state);
 }
@ -229,7 +253,6 @@ Address MixClient::transact(Secret _secret, u256 _endowment, bytes const& _init,
 {
 	WriteGuard l(x_state);
 	u256 n = m_state.transactionsFrom(toAddress(_secret));
-	_gasPrice = 0; //TODO: remove after fixing setBalance
 	eth::Transaction t(_endowment, _gasPrice, _gas, _init, n, _secret);
 	executeTransaction(t, m_state);
 	Address address = right160(sha3(rlpList(t.sender(), t.nonce())));
@ -301,12 +324,12 @@ eth::LocalisedLogEntries MixClient::logs(unsigned _watchId) const
 eth::LocalisedLogEntries MixClient::logs(eth::LogFilter const& _f) const
 {
 	LocalisedLogEntries ret;
-	unsigned lastBlock = m_bc.number();
+	unsigned lastBlock = bc().number();
 	unsigned block = std::min<unsigned>(lastBlock, (unsigned)_f.latest());
 	unsigned end = std::min(lastBlock, std::min(block, (unsigned)_f.earliest()));
 	unsigned skip = _f.skip();
 	// Pending transactions
-	if (block > m_bc.number())
+	if (block > bc().number())
 	{
 		ReadGuard l(x_state);
 		for (unsigned i = 0; i < m_state.pending().size(); ++i)
@ -318,15 +341,15 @@ eth::LocalisedLogEntries MixClient::logs(eth::LogFilter const& _f) const
 				ret.insert(ret.begin(), LocalisedLogEntry(logEntries[entry], block));
 			skip -= std::min(skip, static_cast<unsigned>(logEntries.size()));
 		}
-		block = m_bc.number();
+		block = bc().number();
 	}

 	// The rest
-	auto h = m_bc.numberHash(block);
+	auto h = bc().numberHash(block);
 	for (; ret.size() != block && block != end; block--)
 	{
-		if (_f.matches(m_bc.info(h).logBloom))
-			for (TransactionReceipt receipt: m_bc.receipts(h).receipts)
+		if (_f.matches(bc().info(h).logBloom))
+			for (TransactionReceipt receipt: bc().receipts(h).receipts)
 				if (_f.matches(receipt.bloom()))
 				{
 					LogEntries logEntries = _f.matches(receipt);
@ -334,7 +357,7 @@ eth::LocalisedLogEntries MixClient::logs(eth::LogFilter const& _f) const
 						ret.insert(ret.begin(), LocalisedLogEntry(logEntries[entry], block));
 					skip -= std::min(skip, static_cast<unsigned>(logEntries.size()));
 				}
-		h = m_bc.details(h).parent;
+		h = bc().details(h).parent;
 	}
 	return ret;
 }
@ -416,22 +439,22 @@ LocalisedLogEntries MixClient::checkWatch(unsigned _watchId)

 h256 MixClient::hashFromNumber(unsigned _number) const
 {
-	return m_bc.numberHash(_number);
+	return bc().numberHash(_number);
 }

 eth::BlockInfo MixClient::blockInfo(h256 _hash) const
 {
-	return BlockInfo(m_bc.block(_hash));
+	return BlockInfo(bc().block(_hash));
 }

 eth::BlockDetails MixClient::blockDetails(h256 _hash) const
 {
-	return m_bc.details(_hash);
+	return bc().details(_hash);
 }

 eth::Transaction MixClient::transaction(h256 _blockHash, unsigned _i) const
 {
-	auto bl = m_bc.block(_blockHash);
+	auto bl = bc().block(_blockHash);
 	RLP b(bl);
 	if (_i < b[1].itemCount())
 		return Transaction(b[1][_i].data(), CheckSignature::Range);
@ -441,7 +464,7 @@ eth::Transaction MixClient::transaction(h256 _blockHash, unsigned _i) const

 eth::BlockInfo MixClient::uncle(h256 _blockHash, unsigned _i) const
 {
-	auto bl = m_bc.block(_blockHash);
+	auto bl = bc().block(_blockHash);
 	RLP b(bl);
 	if (_i < b[2].itemCount())
 		return BlockInfo::fromHeader(b[2][_i].data());
@ -451,7 +474,7 @@ eth::BlockInfo MixClient::uncle(h256 _blockHash, unsigned _i) const

 unsigned MixClient::number() const
 {
-	return m_bc.number();
+	return bc().number();
 }

 eth::Transactions MixClient::pending() const
@ -461,7 +484,7 @@ eth::Transactions MixClient::pending() const

 eth::StateDiff MixClient::diff(unsigned _txi, h256 _block) const
 {
-	State st(m_stateDB, m_bc, _block);
+	State st(m_stateDB, bc(), _block);
 	return st.fromPending(_txi).diff(st.fromPending(_txi + 1));
 }

@ -526,3 +549,6 @@ eth::MineProgress MixClient::miningProgress() const
 {
 	return eth::MineProgress();
 }
+
+}
+}
--- a/mix/MixClient.h
+++ b/mix/MixClient.h
@ -27,7 +27,6 @@
 #include <string>
 #include <libethereum/Interface.h>
 #include <libethereum/Client.h>
-#include <libethereum/CanonBlockChain.h>
 #include "MachineStates.h"

 namespace dev
@ -35,6 +34,8 @@ namespace dev
 namespace mix
 {

+class MixBlockChain;
+
 class MixClient: public dev::eth::Interface
 {
 public:
@ -90,12 +91,14 @@ private:
 	void executeTransaction(dev::eth::Transaction const& _t, eth::State& _state);
 	void noteChanged(h256Set const& _filters);
 	dev::eth::State asOf(int _block) const;
+	MixBlockChain& bc() { return *m_bc; }
+	MixBlockChain const& bc() const { return *m_bc; }

 	KeyPair m_userAccount;
 	eth::State m_state;
 	eth::State m_startState;
 	OverlayDB m_stateDB;
-	eth::CanonBlockChain m_bc;
+	std::auto_ptr<MixBlockChain> m_bc;
 	mutable boost::shared_mutex x_state;
 	mutable std::mutex m_filterLock;
 	std::map<h256, dev::eth::InstalledFilter> m_filters;
--- a/mix/qml/WebCodeEditor.qml
+++ b/mix/qml/WebCodeEditor.qml
@ -4,6 +4,7 @@ import QtQuick.Layouts 1.0
 import QtQuick.Controls.Styles 1.1
 import CodeEditorExtensionManager 1.0
 import QtWebEngine 1.0
+import QtWebEngine.experimental 1.0

 Item {
 	signal editorTextChanged
@ -29,6 +30,18 @@ Item {
 		return currentText;
 	}

+	function syncClipboard() {
+		if (Qt.platform.os == "osx") {
+			var text = appContext.clipboard;
+			editorBrowser.runJavaScript("setClipboardBase64(\"" + Qt.btoa(text) + "\")");
+		}
+	}
+
+	Connections {
+		target: appContext
+		onClipboardChanged:	syncClipboard()
+	}
+
 	anchors.top: parent.top
 	id: codeEditorView
 	anchors.fill: parent
@ -36,6 +49,7 @@ Item {
 		id: editorBrowser
 		url: "qrc:///qml/html/codeeditor.html"
 		anchors.fill: parent
+		experimental.settings.javascriptCanAccessClipboard: true
 		onJavaScriptConsoleMessage:  {
 			console.log("editor: " + sourceID + ":" + lineNumber + ":" + message);
 		}
@ -47,6 +61,7 @@ Item {
 				setText(currentText, currentMode);
 				runJavaScript("getTextChanged()", function(result) { });
 				pollTimer.running = true;
+				syncClipboard();
 			}
 		}

--- a/mix/qml/html/cm/codemirror.js
+++ b/mix/qml/html/cm/codemirror.js
@ -29,7 +29,7 @@
  var ie = ie_upto10 || ie_11up;
  var ie_version = ie && (ie_upto10 ? document.documentMode || 6 : ie_11up[1]);
  var webkit = /WebKit\//.test(navigator.userAgent);
-  var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(navigator.userAgent);
+  var qtwebkit = true;
  var chrome = /Chrome\//.test(navigator.userAgent);
  var presto = /Opera\//.test(navigator.userAgent);
  var safari = /Apple Computer/.test(navigator.vendor);
--- a/mix/qml/html/codeeditor.js
+++ b/mix/qml/html/codeeditor.js
@ -6,6 +6,7 @@ var editor = CodeMirror(document.body, {
 							autofocus: true,
 						});

+
 editor.setOption("theme", "solarized dark");
 editor.setOption("indentUnit", 4);
 editor.setOption("indentWithTabs", true);
@ -18,11 +19,24 @@ editor.on("change", function(eMirror, object) {

 });

+var mac = /Mac/.test(navigator.platform);
+if (mac === true) {
+editor.setOption("extraKeys", {
+	"Cmd-V": function(cm) {
+		cm.replaceSelection(clipboard);
+	},
+	"Cmd-X": function(cm) {
+		window.document.execCommand("cut");
+	},
+	"Cmd-C": function(cm) {
+		window.document.execCommand("copy");
+	}});
+}
+
 getTextChanged = function() {
 	return editor.changeRegistered;
 };

-
 getText = function() {
 	editor.changeRegistered = false;
 	return editor.getValue();
@ -42,3 +56,7 @@ setText = function(text) {
 setMode = function(mode) {
 	this.editor.setOption("mode", mode);
 };
+
+setClipboardBase64 = function(text) {
+	clipboard = window.atob(text);
+};
--- a/sc/CMakeLists.txt
+++ b/sc/CMakeLists.txt
@ -8,7 +8,9 @@ set(EXECUTABLE sc)

 add_executable(${EXECUTABLE} ${SRC_LIST})

+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
 target_link_libraries(${EXECUTABLE} serpent)
+endif()
 target_link_libraries(${EXECUTABLE} lll)
 target_link_libraries(${EXECUTABLE} evmcore)
 target_link_libraries(${EXECUTABLE} devcore)
--- a/third/CMakeLists.txt
+++ b/third/CMakeLists.txt
@ -38,7 +38,9 @@ target_link_libraries(${EXECUTABLE} ethereum)
 target_link_libraries(${EXECUTABLE} evm)
 target_link_libraries(${EXECUTABLE} ethcore) 
 target_link_libraries(${EXECUTABLE} secp256k1) 
+if (NOT ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC"))
 target_link_libraries(${EXECUTABLE} serpent)
+endif()
 target_link_libraries(${EXECUTABLE} lll) 
 target_link_libraries(${EXECUTABLE} evmcore) 
 target_link_libraries(${EXECUTABLE} devcore)