diff --git a/alethzero/MainWin.cpp b/alethzero/MainWin.cpp
index 967bc6b56..0d440089b 100644
--- a/alethzero/MainWin.cpp
+++ b/alethzero/MainWin.cpp
@@ -583,7 +583,7 @@ Address Main::fromString(QString const& _n) const
 	{
 		try
 		{
-			return Address(fromHex(_n.toStdString(), ThrowType::Throw));
+			return Address(fromHex(_n.toStdString(), WhenError::Throw));
 		}
 		catch (BadHexCharacter& _e)
 		{
@@ -1388,7 +1388,7 @@ void Main::on_inject_triggered()
 	QString s = QInputDialog::getText(this, "Inject Transaction", "Enter transaction dump in hex");
 	try
 	{
-		bytes b = fromHex(s.toStdString(), ThrowType::Throw);
+		bytes b = fromHex(s.toStdString(), WhenError::Throw);
 		ethereum()->inject(&b);
 	}
 	catch (BadHexCharacter& _e)
diff --git a/alethzero/Transact.cpp b/alethzero/Transact.cpp
index 2c77895ff..d89b2ef3c 100644
--- a/alethzero/Transact.cpp
+++ b/alethzero/Transact.cpp
@@ -284,6 +284,7 @@ void Transact::on_send_clicked()
 			{
 				// If execution is a contract creation, add Natspec to
 				// a local Natspec LEVELDB
+				ExecutionResult er = ethereum()->create(s, value(), m_data, ui->gas->value(), gasPrice());
 				ethereum()->submitTransaction(s, value(), m_data, ui->gas->value(), gasPrice());
 				string src = ui->data->toPlainText().toStdString();
 				if (sourceIsSolidity(src))
diff --git a/eth/main.cpp b/eth/main.cpp
index 81e910716..88eb206b2 100644
--- a/eth/main.cpp
+++ b/eth/main.cpp
@@ -273,10 +273,9 @@ int main(int argc, char** argv)
 		else if ((arg == "-c" || arg == "--client-name") && i + 1 < argc)
 			clientName = argv[++i];
 		else if ((arg == "-a" || arg == "--address" || arg == "--coinbase-address") && i + 1 < argc)
-		{
 			try
 			{
-				coinbase = h160(fromHex(argv[++i], ThrowType::Throw));
+				coinbase = h160(fromHex(argv[++i], WhenError::Throw));
 			}
 			catch (BadHexCharacter& _e)
 			{
@@ -289,7 +288,6 @@ int main(int argc, char** argv)
 				cwarn << "coinbase rejected";
 				break;
 			}
-		}
 		else if ((arg == "-s" || arg == "--secret") && i + 1 < argc)
 			us = KeyPair(h256(fromHex(argv[++i])));
 		else if (arg == "--structured-logging-format" && i + 1 < argc)
@@ -300,20 +298,24 @@ int main(int argc, char** argv)
 			dbPath = argv[++i];
 		else if ((arg == "-B" || arg == "--block-fees") && i + 1 < argc)
 		{
-			try {
+			try
+			{
 				blockFees = stof(argv[++i]);
 			}
-			catch (...) {
+			catch (...)
+			{
 				cerr << "Bad " << arg << " option: " << argv[++i] << endl;
 				return -1;
 			}
 		}
 		else if ((arg == "-e" || arg == "--ether-price") && i + 1 < argc)
 		{
-			try {
+			try
+			{
 				etherPrice = stof(argv[++i]);
 			}
-			catch (...) {
+			catch (...)
+			{
 				cerr << "Bad " << arg << " option: " << argv[++i] << endl;
 				return -1;
 			}
@@ -434,7 +436,8 @@ int main(int argc, char** argv)
 		c->setAddress(coinbase);
 	}
 
-	cout << "Address: " << endl << toHex(us.address().asArray()) << endl;
+	cout << "Transaction Signer: " << us.address() << endl;
+	cout << "Mining Benefactor: " << coinbase << endl;
 	web3.startNetwork();
 
 	if (bootstrap)
@@ -720,7 +723,7 @@ int main(int argc, char** argv)
 						u256 minGas = (u256)Client::txGas(bytes(), 0);
 						try
 						{
-							Address dest = h160(fromHex(hexAddr, ThrowType::Throw));
+							Address dest = h160(fromHex(hexAddr, WhenError::Throw));
 							c->submitTransaction(us.secret(), amount, dest, bytes(), minGas);
 						}
 						catch (BadHexCharacter& _e)
@@ -764,7 +767,7 @@ int main(int argc, char** argv)
 						stringstream ssc;
 						try
 						{
-							init = fromHex(sinit, ThrowType::Throw);
+							init = fromHex(sinit, WhenError::Throw);
 						}
 						catch (BadHexCharacter& _e)
 						{
@@ -925,7 +928,7 @@ int main(int argc, char** argv)
 					{
 						try
 						{
-							coinbase = h160(fromHex(hexAddr, ThrowType::Throw));
+							coinbase = h160(fromHex(hexAddr, WhenError::Throw));
 						}
 						catch (BadHexCharacter& _e)
 						{
diff --git a/evmjit/libevmjit/Arith256.cpp b/evmjit/libevmjit/Arith256.cpp
index f24626750..e88fda432 100644
--- a/evmjit/libevmjit/Arith256.cpp
+++ b/evmjit/libevmjit/Arith256.cpp
@@ -371,17 +371,18 @@ llvm::Value* Arith256::mul(llvm::Value* _arg1, llvm::Value* _arg2)
 
 std::pair<llvm::Value*, llvm::Value*> Arith256::div(llvm::Value* _arg1, llvm::Value* _arg2)
 {
-	if (auto c1 = llvm::dyn_cast<llvm::ConstantInt>(_arg1))
-	{
-		if (auto c2 = llvm::dyn_cast<llvm::ConstantInt>(_arg2))
-		{
-			if (!c2->getValue())
-				return std::make_pair(Constant::get(0), Constant::get(0));
-			auto div = Constant::get(c1->getValue().udiv(c2->getValue()));
-			auto mod = Constant::get(c1->getValue().urem(c2->getValue()));
-			return std::make_pair(div, mod);
-		}
-	}
+	// FIXME: Disabled because of llvm::APInt::urem bug
+//	if (auto c1 = llvm::dyn_cast<llvm::ConstantInt>(_arg1))
+//	{
+//		if (auto c2 = llvm::dyn_cast<llvm::ConstantInt>(_arg2))
+//		{
+//			if (!c2->getValue())
+//				return std::make_pair(Constant::get(0), Constant::get(0));
+//			auto div = Constant::get(c1->getValue().udiv(c2->getValue()));
+//			auto mod = Constant::get(c1->getValue().urem(c2->getValue()));
+//			return std::make_pair(div, mod);
+//		}
+//	}
 
 	auto r = createCall(getDivFunc(Type::Word), {_arg1, _arg2});
 	auto div =  m_builder.CreateExtractValue(r, 0, "div");
@@ -391,17 +392,18 @@ std::pair<llvm::Value*, llvm::Value*> Arith256::div(llvm::Value* _arg1, llvm::Va
 
 std::pair<llvm::Value*, llvm::Value*> Arith256::sdiv(llvm::Value* _x, llvm::Value* _y)
 {
-	if (auto c1 = llvm::dyn_cast<llvm::ConstantInt>(_x))
-	{
-		if (auto c2 = llvm::dyn_cast<llvm::ConstantInt>(_y))
-		{
-			if (!c2->getValue())
-				return std::make_pair(Constant::get(0), Constant::get(0));
-			auto div = Constant::get(c1->getValue().sdiv(c2->getValue()));
-			auto mod = Constant::get(c1->getValue().srem(c2->getValue()));
-			return std::make_pair(div, mod);
-		}
-	}
+	// FIXME: Disabled because of llvm::APInt::urem bug
+//	if (auto c1 = llvm::dyn_cast<llvm::ConstantInt>(_x))
+//	{
+//		if (auto c2 = llvm::dyn_cast<llvm::ConstantInt>(_y))
+//		{
+//			if (!c2->getValue())
+//				return std::make_pair(Constant::get(0), Constant::get(0));
+//			auto div = Constant::get(c1->getValue().sdiv(c2->getValue()));
+//			auto mod = Constant::get(c1->getValue().srem(c2->getValue()));
+//			return std::make_pair(div, mod);
+//		}
+//	}
 
 	auto xIsNeg = m_builder.CreateICmpSLT(_x, Constant::get(0));
 	auto xNeg = m_builder.CreateSub(Constant::get(0), _x);
diff --git a/libdevcore/CommonData.cpp b/libdevcore/CommonData.cpp
index 17e393cbe..6cad29952 100644
--- a/libdevcore/CommonData.cpp
+++ b/libdevcore/CommonData.cpp
@@ -78,7 +78,7 @@ int dev::fromHex(char _i)
 	BOOST_THROW_EXCEPTION(BadHexCharacter() << errinfo_invalidSymbol(_i));
 }
 
-bytes dev::fromHex(std::string const& _s, ThrowType _throw)
+bytes dev::fromHex(std::string const& _s, WhenError _throw)
 {
 	unsigned s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;
 	std::vector<uint8_t> ret;
@@ -96,7 +96,7 @@ bytes dev::fromHex(std::string const& _s, ThrowType _throw)
 #ifndef BOOST_NO_EXCEPTIONS
 			cwarn << boost::current_exception_diagnostic_information(); 
 #endif
-			if (_throw == ThrowType::Throw)
+			if (_throw == WhenError::Throw)
 				throw;
 		}
 	for (unsigned i = s; i < _s.size(); i += 2)
@@ -109,7 +109,7 @@ bytes dev::fromHex(std::string const& _s, ThrowType _throw)
 #ifndef BOOST_NO_EXCEPTIONS
 			cwarn << boost::current_exception_diagnostic_information();
 #endif
-			if (_throw == ThrowType::Throw)
+			if (_throw == WhenError::Throw)
 				throw;
 		}
 	return ret;
diff --git a/libdevcore/CommonData.h b/libdevcore/CommonData.h
index 2c9fd30ef..1c7a4cd61 100644
--- a/libdevcore/CommonData.h
+++ b/libdevcore/CommonData.h
@@ -35,9 +35,9 @@ namespace dev
 
 // String conversion functions, mainly to/from hex/nibble/byte representations.
 
-enum class ThrowType
+enum class WhenError
 {
-	NoThrow = 0,
+	DontThrow = 0,
 	Throw = 1,
 };
 
@@ -59,8 +59,8 @@ int fromHex(char _i);
 
 /// Converts a (printable) ASCII hex string into the corresponding byte stream.
 /// @example fromHex("41626261") == asBytes("Abba")
-/// If _throw = ThrowType::NoThrow, it replaces bad hex characters with 0's, otherwise it will throw an exception.
-bytes fromHex(std::string const& _s, ThrowType _throw = ThrowType::NoThrow);
+/// If _throw = ThrowType::DontThrow, it replaces bad hex characters with 0's, otherwise it will throw an exception.
+bytes fromHex(std::string const& _s, WhenError _throw = WhenError::DontThrow);
 
 #if 0
 std::string toBase58(bytesConstRef _data);
diff --git a/libethereum/Transaction.h b/libethereum/Transaction.h
index 85543a3fc..8cb6cb7fc 100644
--- a/libethereum/Transaction.h
+++ b/libethereum/Transaction.h
@@ -66,7 +66,7 @@ enum class CodeDeposit
 	Success
 };
 
-class VMException;
+struct VMException;
 
 TransactionException toTransactionException(VMException const& _e);
 
diff --git a/libsolidity/ArrayUtils.cpp b/libsolidity/ArrayUtils.cpp
index 2596e4afa..bbf7f985a 100644
--- a/libsolidity/ArrayUtils.cpp
+++ b/libsolidity/ArrayUtils.cpp
@@ -52,15 +52,21 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 	// TODO unroll loop for small sizes
 
 	bool sourceIsStorage = _sourceType.getLocation() == ArrayType::Location::Storage;
+	bool directCopy = sourceIsStorage && sourceBaseType->isValueType() && *sourceBaseType == *targetBaseType;
+	bool haveByteOffsetSource = !directCopy && sourceIsStorage && sourceBaseType->getStorageBytes() <= 16;
+	bool haveByteOffsetTarget = !directCopy && targetBaseType->getStorageBytes() <= 16;
+	unsigned byteOffsetSize = (haveByteOffsetSource ? 1 : 0) + (haveByteOffsetTarget ? 1 : 0);
 
 	// stack: source_ref [source_byte_off] [source_length] target_ref target_byte_off
 	// store target_ref
-	m_context << eth::Instruction::POP; //@todo
+	// arrays always start at zero byte offset, pop offset
+	m_context << eth::Instruction::POP;
 	for (unsigned i = _sourceType.getSizeOnStack(); i > 0; --i)
 		m_context << eth::swapInstruction(i);
 	// stack: target_ref source_ref [source_byte_off] [source_length]
 	if (sourceIsStorage)
-		m_context << eth::Instruction::POP; //@todo
+		// arrays always start at zero byte offset, pop offset
+		m_context << eth::Instruction::POP;
 	// stack: target_ref source_ref [source_length]
 	// retrieve source length
 	if (_sourceType.getLocation() != ArrayType::Location::CallData || !_sourceType.isDynamicallySized())
@@ -81,7 +87,7 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 		m_context
 			<< eth::Instruction::POP << eth::Instruction::POP
 			<< eth::Instruction::POP << eth::Instruction::POP;
-		m_context << u256(0); //@todo
+		m_context << u256(0);
 		return;
 	}
 	// compute hashes (data positions)
@@ -97,8 +103,8 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 	// stack: target_ref target_data_end source_length target_data_pos source_ref
 	// skip copying if source length is zero
 	m_context << eth::Instruction::DUP3 << eth::Instruction::ISZERO;
-	eth::AssemblyItem copyLoopEnd = m_context.newTag();
-	m_context.appendConditionalJumpTo(copyLoopEnd);
+	eth::AssemblyItem copyLoopEndWithoutByteOffset = m_context.newTag();
+	m_context.appendConditionalJumpTo(copyLoopEndWithoutByteOffset);
 
 	if (_sourceType.getLocation() == ArrayType::Location::Storage && _sourceType.isDynamicallySized())
 		CompilerUtils(m_context).computeHashStatic();
@@ -107,18 +113,24 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 	convertLengthToSize(_sourceType);
 	m_context << eth::Instruction::DUP3 << eth::Instruction::ADD;
 	// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end
+	if (haveByteOffsetTarget)
+		m_context << u256(0);
+	if (haveByteOffsetSource)
+		m_context << u256(0);
+	// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
 	eth::AssemblyItem copyLoopStart = m_context.newTag();
 	m_context << copyLoopStart;
 	// check for loop condition
 	m_context
-		<< eth::Instruction::DUP3 << eth::Instruction::DUP2
+		<< eth::dupInstruction(3 + byteOffsetSize) << eth::dupInstruction(2 + byteOffsetSize)
 		<< eth::Instruction::GT << eth::Instruction::ISZERO;
+	eth::AssemblyItem copyLoopEnd = m_context.newTag();
 	m_context.appendConditionalJumpTo(copyLoopEnd);
-	// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end
+	// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
 	// copy
 	if (sourceBaseType->getCategory() == Type::Category::Array)
 	{
-		//@todo
+		solAssert(byteOffsetSize == 0, "Byte offset for array as base type.");
 		m_context << eth::Instruction::DUP3;
 		if (sourceIsStorage)
 			m_context << u256(0);
@@ -129,36 +141,80 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 		);
 		m_context << eth::Instruction::POP << eth::Instruction::POP;
 	}
+	else if (directCopy)
+	{
+		solAssert(byteOffsetSize == 0, "Byte offset for direct copy.");
+		m_context
+			<< eth::Instruction::DUP3 << eth::Instruction::SLOAD
+			<< eth::Instruction::DUP3 << eth::Instruction::SSTORE;
+	}
 	else
 	{
-		m_context << eth::Instruction::DUP3;
+		// Note that we have to copy each element on its own in case conversion is involved.
+		// We might copy too much if there is padding at the last element, but this way end
+		// checking is easier.
+		// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
+		m_context << eth::dupInstruction(3 + byteOffsetSize);
 		if (_sourceType.getLocation() == ArrayType::Location::Storage)
 		{
-			m_context << u256(0);
+			if (haveByteOffsetSource)
+				m_context << eth::Instruction::DUP2;
+			else
+				m_context << u256(0);
 			StorageItem(m_context, *sourceBaseType).retrieveValue(SourceLocation(), true);
 		}
 		else if (sourceBaseType->isValueType())
 			CompilerUtils(m_context).loadFromMemoryDynamic(*sourceBaseType, true, true, false);
 		else
 			solAssert(false, "Copying of unknown type requested: " + sourceBaseType->toString());
-		solAssert(2 + sourceBaseType->getSizeOnStack() <= 16, "Stack too deep.");
-		m_context << eth::dupInstruction(2 + sourceBaseType->getSizeOnStack()) << u256(0);
+		// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset] <source_value>...
+		solAssert(2 + byteOffsetSize + sourceBaseType->getSizeOnStack() <= 16, "Stack too deep.");
+		// fetch target storage reference
+		m_context << eth::dupInstruction(2 + byteOffsetSize + sourceBaseType->getSizeOnStack());
+		if (haveByteOffsetTarget)
+			m_context << eth::dupInstruction(1 + byteOffsetSize + sourceBaseType->getSizeOnStack());
+		else
+			m_context << u256(0);
 		StorageItem(m_context, *targetBaseType).storeValue(*sourceBaseType, SourceLocation(), true);
 	}
+	// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end [target_byte_offset] [source_byte_offset]
 	// increment source
-	m_context
-		<< eth::Instruction::SWAP2
-		<< (sourceIsStorage ? sourceBaseType->getStorageSize() : sourceBaseType->getCalldataEncodedSize())
-		<< eth::Instruction::ADD
-		<< eth::Instruction::SWAP2;
+	if (haveByteOffsetSource)
+		incrementByteOffset(sourceBaseType->getStorageBytes(), 1, haveByteOffsetTarget ? 5 : 4);
+	else
+		m_context
+			<< eth::swapInstruction(2 + byteOffsetSize)
+			<< (sourceIsStorage ? sourceBaseType->getStorageSize() : sourceBaseType->getCalldataEncodedSize())
+			<< eth::Instruction::ADD
+			<< eth::swapInstruction(2 + byteOffsetSize);
 	// increment target
-	m_context
-		<< eth::Instruction::SWAP1
-		<< targetBaseType->getStorageSize()
-		<< eth::Instruction::ADD
-		<< eth::Instruction::SWAP1;
+	if (haveByteOffsetTarget)
+		incrementByteOffset(targetBaseType->getStorageBytes(), byteOffsetSize, byteOffsetSize + 2);
+	else
+		m_context
+			<< eth::swapInstruction(1 + byteOffsetSize)
+			<< targetBaseType->getStorageSize()
+			<< eth::Instruction::ADD
+			<< eth::swapInstruction(1 + byteOffsetSize);
 	m_context.appendJumpTo(copyLoopStart);
 	m_context << copyLoopEnd;
+	if (haveByteOffsetTarget)
+	{
+		// clear elements that might be left over in the current slot in target
+		// stack: target_ref target_data_end source_data_pos target_data_pos source_data_end target_byte_offset [source_byte_offset]
+		m_context << eth::dupInstruction(byteOffsetSize) << eth::Instruction::ISZERO;
+		eth::AssemblyItem copyCleanupLoopEnd = m_context.appendConditionalJump();
+		m_context << eth::dupInstruction(2 + byteOffsetSize) << eth::dupInstruction(1 + byteOffsetSize);
+		StorageItem(m_context, *targetBaseType).setToZero(SourceLocation(), true);
+		incrementByteOffset(targetBaseType->getStorageBytes(), byteOffsetSize, byteOffsetSize + 2);
+		m_context.appendJumpTo(copyLoopEnd);
+
+		m_context << copyCleanupLoopEnd;
+		m_context << eth::Instruction::POP; // might pop the source, but then target is popped next
+	}
+	if (haveByteOffsetSource)
+		m_context << eth::Instruction::POP;
+	m_context << copyLoopEndWithoutByteOffset;
 
 	// zero-out leftovers in target
 	// stack: target_ref target_data_end source_data_pos target_data_pos_updated source_data_end
@@ -166,41 +222,61 @@ void ArrayUtils::copyArrayToStorage(ArrayType const& _targetType, ArrayType cons
 	// stack: target_ref target_data_end target_data_pos_updated
 	clearStorageLoop(*targetBaseType);
 	m_context << eth::Instruction::POP;
-	m_context << u256(0); //@todo
+	m_context << u256(0);
 }
 
 void ArrayUtils::clearArray(ArrayType const& _type) const
 {
 	unsigned stackHeightStart = m_context.getStackHeight();
 	solAssert(_type.getLocation() == ArrayType::Location::Storage, "");
-	if (_type.isDynamicallySized())
+	if (_type.getBaseType()->getStorageBytes() < 32)
 	{
-		m_context << eth::Instruction::POP; // remove byte offset
-		clearDynamicArray(_type);
+		solAssert(_type.getBaseType()->isValueType(), "Invalid storage size for non-value type.");
+		solAssert(_type.getBaseType()->getStorageSize() <= 1, "Invalid storage size for type.");
 	}
+	if (_type.getBaseType()->isValueType())
+		solAssert(_type.getBaseType()->getStorageSize() <= 1, "Invalid size for value type.");
+
+	m_context << eth::Instruction::POP; // remove byte offset
+	if (_type.isDynamicallySized())
+		clearDynamicArray(_type);
 	else if (_type.getLength() == 0 || _type.getBaseType()->getCategory() == Type::Category::Mapping)
-		m_context << eth::Instruction::POP << eth::Instruction::POP;
-	else if (_type.getLength() < 5) // unroll loop for small arrays @todo choose a good value
+		m_context << eth::Instruction::POP;
+	else if (_type.getBaseType()->isValueType() && _type.getStorageSize() <= 5)
+	{
+		// unroll loop for small arrays @todo choose a good value
+		// Note that we loop over storage slots here, not elements.
+		for (unsigned i = 1; i < _type.getStorageSize(); ++i)
+			m_context
+				<< u256(0) << eth::Instruction::DUP2 << eth::Instruction::SSTORE
+				<< u256(1) << eth::Instruction::ADD;
+		m_context << u256(0) << eth::Instruction::SWAP1 << eth::Instruction::SSTORE;
+	}
+	else if (!_type.getBaseType()->isValueType() && _type.getLength() <= 4)
 	{
-		solAssert(!_type.isByteArray(), "");
+		// unroll loop for small arrays @todo choose a good value
+		solAssert(_type.getBaseType()->getStorageBytes() >= 32, "Invalid storage size.");
 		for (unsigned i = 1; i < _type.getLength(); ++i)
 		{
+			m_context << u256(0);
 			StorageItem(m_context, *_type.getBaseType()).setToZero(SourceLocation(), false);
-			m_context << eth::Instruction::SWAP1;
-			m_context << u256(_type.getBaseType()->getStorageSize()) << eth::Instruction::ADD;
-			m_context << eth::Instruction::SWAP1;
+			m_context
+				<< eth::Instruction::POP
+				<< u256(_type.getBaseType()->getStorageSize()) << eth::Instruction::ADD;
 		}
+		m_context << u256(0);
 		StorageItem(m_context, *_type.getBaseType()).setToZero(SourceLocation(), true);
 	}
 	else
 	{
-		solAssert(!_type.isByteArray(), "");
-		m_context << eth::Instruction::SWAP1;
 		m_context << eth::Instruction::DUP1 << _type.getLength();
 		convertLengthToSize(_type);
 		m_context << eth::Instruction::ADD << eth::Instruction::SWAP1;
-		clearStorageLoop(*_type.getBaseType());
-		m_context << eth::Instruction::POP << eth::Instruction::POP;
+		if (_type.getBaseType()->getStorageBytes() < 32)
+			clearStorageLoop(IntegerType(256));
+		else
+			clearStorageLoop(*_type.getBaseType());
+		m_context << eth::Instruction::POP;
 	}
 	solAssert(m_context.getStackHeight() == stackHeightStart - 2, "");
 }
@@ -224,7 +300,7 @@ void ArrayUtils::clearDynamicArray(ArrayType const& _type) const
 	m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2 << eth::Instruction::ADD
 		<< eth::Instruction::SWAP1;
 	// stack: data_pos_end data_pos
-	if (_type.isByteArray())
+	if (_type.isByteArray() || _type.getBaseType()->getStorageBytes() < 32)
 		clearStorageLoop(IntegerType(256));
 	else
 		clearStorageLoop(*_type.getBaseType());
@@ -237,6 +313,8 @@ void ArrayUtils::resizeDynamicArray(const ArrayType& _type) const
 {
 	solAssert(_type.getLocation() == ArrayType::Location::Storage, "");
 	solAssert(_type.isDynamicallySized(), "");
+	if (!_type.isByteArray() && _type.getBaseType()->getStorageBytes() < 32)
+		solAssert(_type.getBaseType()->isValueType(), "Invalid storage size for non-value type.");
 
 	unsigned stackHeightStart = m_context.getStackHeight();
 	eth::AssemblyItem resizeEnd = m_context.newTag();
@@ -266,7 +344,7 @@ void ArrayUtils::resizeDynamicArray(const ArrayType& _type) const
 	// stack: ref new_length data_pos new_size delete_end
 	m_context << eth::Instruction::SWAP2 << eth::Instruction::ADD;
 	// stack: ref new_length delete_end delete_start
-	if (_type.isByteArray())
+	if (_type.isByteArray() || _type.getBaseType()->getStorageBytes() < 32)
 		clearStorageLoop(IntegerType(256));
 	else
 		clearStorageLoop(*_type.getBaseType());
@@ -294,7 +372,7 @@ void ArrayUtils::clearStorageLoop(Type const& _type) const
 	eth::AssemblyItem zeroLoopEnd = m_context.newTag();
 	m_context.appendConditionalJumpTo(zeroLoopEnd);
 	// delete
-	m_context << u256(0); //@todo
+	m_context << u256(0);
 	StorageItem(m_context, _type).setToZero(SourceLocation(), false);
 	m_context << eth::Instruction::POP;
 	// increment
@@ -313,7 +391,20 @@ void ArrayUtils::convertLengthToSize(ArrayType const& _arrayType, bool _pad) con
 		if (_arrayType.isByteArray())
 			m_context << u256(31) << eth::Instruction::ADD
 				<< u256(32) << eth::Instruction::SWAP1 << eth::Instruction::DIV;
-		else if (_arrayType.getBaseType()->getStorageSize() > 1)
+		else if (_arrayType.getBaseType()->getStorageSize() <= 1)
+		{
+			unsigned baseBytes = _arrayType.getBaseType()->getStorageBytes();
+			if (baseBytes == 0)
+				m_context << eth::Instruction::POP << u256(1);
+			else if (baseBytes <= 16)
+			{
+				unsigned itemsPerSlot = 32 / baseBytes;
+				m_context
+					<< u256(itemsPerSlot - 1) << eth::Instruction::ADD
+					<< u256(itemsPerSlot) << eth::Instruction::SWAP1 << eth::Instruction::DIV;
+			}
+		}
+		else
 			m_context << _arrayType.getBaseType()->getStorageSize() << eth::Instruction::MUL;
 	}
 	else
@@ -349,3 +440,39 @@ void ArrayUtils::retrieveLength(ArrayType const& _arrayType) const
 	}
 }
 
+void ArrayUtils::incrementByteOffset(unsigned _byteSize, unsigned _byteOffsetPosition, unsigned _storageOffsetPosition) const
+{
+	solAssert(_byteSize < 32, "");
+	solAssert(_byteSize != 0, "");
+	// We do the following, but avoiding jumps:
+	// byteOffset += byteSize
+	// if (byteOffset + byteSize > 32)
+	// {
+	//     storageOffset++;
+	//     byteOffset = 0;
+	// }
+	if (_byteOffsetPosition > 1)
+		m_context << eth::swapInstruction(_byteOffsetPosition - 1);
+	m_context << u256(_byteSize) << eth::Instruction::ADD;
+	if (_byteOffsetPosition > 1)
+		m_context << eth::swapInstruction(_byteOffsetPosition - 1);
+	// compute, X := (byteOffset + byteSize - 1) / 32, should be 1 iff byteOffset + bytesize > 32
+	m_context
+		<< u256(32) << eth::dupInstruction(1 + _byteOffsetPosition) << u256(_byteSize - 1)
+		<< eth::Instruction::ADD << eth::Instruction::DIV;
+	// increment storage offset if X == 1 (just add X to it)
+	// stack: X
+	m_context
+		<< eth::swapInstruction(_storageOffsetPosition) << eth::dupInstruction(_storageOffsetPosition + 1)
+		<< eth::Instruction::ADD << eth::swapInstruction(_storageOffsetPosition);
+	// stack: X
+	// set source_byte_offset to zero if X == 1 (using source_byte_offset *= 1 - X)
+	m_context << u256(1) << eth::Instruction::SUB;
+	// stack: 1 - X
+	if (_byteOffsetPosition == 1)
+		m_context << eth::Instruction::MUL;
+	else
+		m_context
+			<< eth::dupInstruction(_byteOffsetPosition + 1) << eth::Instruction::MUL
+			<< eth::swapInstruction(_byteOffsetPosition) << eth::Instruction::POP;
+}
diff --git a/libsolidity/ArrayUtils.h b/libsolidity/ArrayUtils.h
index c7b05b6d3..22c0646a5 100644
--- a/libsolidity/ArrayUtils.h
+++ b/libsolidity/ArrayUtils.h
@@ -72,6 +72,12 @@ public:
 	void retrieveLength(ArrayType const& _arrayType) const;
 
 private:
+	/// Adds the given number of bytes to a storage byte offset counter and also increments
+	/// the storage offset if adding this number again would increase the counter over 32.
+	/// @param byteOffsetPosition the stack offset of the storage byte offset
+	/// @param storageOffsetPosition the stack offset of the storage slot offset
+	void incrementByteOffset(unsigned _byteSize, unsigned _byteOffsetPosition, unsigned _storageOffsetPosition) const;
+
 	CompilerContext& m_context;
 };
 
diff --git a/libsolidity/Compiler.cpp b/libsolidity/Compiler.cpp
index db61cc4a1..8e2634499 100644
--- a/libsolidity/Compiler.cpp
+++ b/libsolidity/Compiler.cpp
@@ -20,12 +20,12 @@
  * Solidity compiler.
  */
 
+#include <libsolidity/Compiler.h>
 #include <algorithm>
 #include <boost/range/adaptor/reversed.hpp>
 #include <libevmcore/Instruction.h>
 #include <libevmcore/Assembly.h>
 #include <libsolidity/AST.h>
-#include <libsolidity/Compiler.h>
 #include <libsolidity/ExpressionCompiler.h>
 #include <libsolidity/CompilerUtils.h>
 
@@ -274,19 +274,8 @@ void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters)
 
 void Compiler::registerStateVariables(ContractDefinition const& _contract)
 {
-	vector<VariableDeclaration const*> variables;
-	for (ContractDefinition const* contract: boost::adaptors::reverse(_contract.getLinearizedBaseContracts()))
-		for (ASTPointer<VariableDeclaration> const& variable: contract->getStateVariables())
-			if (!variable->isConstant())
-				variables.push_back(variable.get());
-	TypePointers types;
-	for (auto variable: variables)
-		types.push_back(variable->getType());
-	StorageOffsets offsets;
-	offsets.computeOffsets(types);
-	for (size_t index = 0; index < variables.size(); ++index)
-		if (auto const* offset = offsets.getOffset(index))
-			m_context.addStateVariable(*variables[index], offset->first, offset->second);
+	for (auto const& var: ContractType(_contract).getStateVariables())
+		m_context.addStateVariable(*get<0>(var), get<1>(var), get<2>(var));
 }
 
 void Compiler::initializeStateVariables(ContractDefinition const& _contract)
diff --git a/libsolidity/ExpressionCompiler.cpp b/libsolidity/ExpressionCompiler.cpp
index 61b17f663..da762147a 100644
--- a/libsolidity/ExpressionCompiler.cpp
+++ b/libsolidity/ExpressionCompiler.cpp
@@ -753,7 +753,6 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 	}
 	else if (baseType.getCategory() == Type::Category::Array)
 	{
-		// stack layout: <base_ref> [storage_byte_offset] [<length>] <index>
 		ArrayType const& arrayType = dynamic_cast<ArrayType const&>(baseType);
 		solAssert(_indexAccess.getIndexExpression(), "Index expression expected.");
 		ArrayType::Location location = arrayType.getLocation();
@@ -762,6 +761,11 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 			location == ArrayType::Location::Memory ? eth::Instruction::MLOAD :
 			eth::Instruction::CALLDATALOAD;
 
+		// remove storage byte offset
+		if (location == ArrayType::Location::Storage)
+			m_context << eth::Instruction::POP;
+
+		// stack layout: <base_ref> [<length>] <index>
 		_indexAccess.getIndexExpression()->accept(*this);
 		// retrieve length
 		if (!arrayType.isDynamicallySized())
@@ -769,11 +773,9 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 		else if (location == ArrayType::Location::CallData)
 			// length is stored on the stack
 			m_context << eth::Instruction::SWAP1;
-		else if (location == ArrayType::Location::Storage)
-			m_context << eth::Instruction::DUP3 << load;
 		else
 			m_context << eth::Instruction::DUP2 << load;
-		// stack: <base_ref> [storage_byte_offset] <index> <length>
+		// stack: <base_ref> <index> <length>
 		// check out-of-bounds access
 		m_context << eth::Instruction::DUP2 << eth::Instruction::LT;
 		eth::AssemblyItem legalAccess = m_context.appendConditionalJump();
@@ -781,23 +783,22 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 		m_context << eth::Instruction::STOP;
 
 		m_context << legalAccess;
-		// stack: <base_ref> [storage_byte_offset] <index>
+		// stack: <base_ref> <index>
 		if (arrayType.isByteArray())
-			// byte array is packed differently, especially in storage
 			switch (location)
 			{
 			case ArrayType::Location::Storage:
 				// byte array index storage lvalue on stack (goal):
 				// <ref> <byte_number> = <base_ref + index / 32> <index % 32>
-				m_context << u256(32) << eth::Instruction::SWAP3;
+				m_context << u256(32) << eth::Instruction::SWAP2;
 				CompilerUtils(m_context).computeHashStatic();
-				// stack: 32 storage_byte_offset index data_ref
+				// stack: 32 index data_ref
 				m_context
-					<< eth::Instruction::DUP4 << eth::Instruction::DUP3
+					<< eth::Instruction::DUP3 << eth::Instruction::DUP3
 					<< eth::Instruction::DIV << eth::Instruction::ADD
-				// stack: 32 storage_byte_offset index (data_ref + index / 32)
-					<< eth::Instruction::SWAP3 << eth::Instruction::SWAP2
-					<< eth::Instruction::POP << eth::Instruction::MOD;
+				// stack: 32 index (data_ref + index / 32)
+					<< eth::Instruction::SWAP2 << eth::Instruction::SWAP1
+					<< eth::Instruction::MOD;
 				setLValue<StorageByteArrayElement>(_indexAccess);
 				break;
 			case ArrayType::Location::CallData:
@@ -811,36 +812,51 @@ bool ExpressionCompiler::visit(IndexAccess const& _indexAccess)
 			}
 		else
 		{
-			// stack: <base_ref> [storage_byte_offset] <index>
-			if (location == ArrayType::Location::Storage)
-				//@todo use byte offset, remove it for now
-				m_context << eth::Instruction::SWAP1 << eth::Instruction::POP;
-			u256 elementSize =
-				location == ArrayType::Location::Storage ?
-					arrayType.getBaseType()->getStorageSize() :
-					arrayType.getBaseType()->getCalldataEncodedSize();
-			solAssert(elementSize != 0, "Invalid element size.");
-			if (elementSize > 1)
-				m_context << elementSize << eth::Instruction::MUL;
+			// stack: <base_ref> <index>
+			m_context << eth::Instruction::SWAP1;
 			if (arrayType.isDynamicallySized())
 			{
 				if (location == ArrayType::Location::Storage)
-				{
-					m_context << eth::Instruction::SWAP1;
 					CompilerUtils(m_context).computeHashStatic();
-				}
 				else if (location == ArrayType::Location::Memory)
 					m_context << u256(32) << eth::Instruction::ADD;
 			}
-			m_context << eth::Instruction::ADD;
+			// stack: <index> <data_ref>
 			switch (location)
 			{
 			case ArrayType::Location::CallData:
+				m_context
+					<< eth::Instruction::SWAP1 << arrayType.getBaseType()->getCalldataEncodedSize()
+					<< eth::Instruction::MUL << eth::Instruction::ADD;
 				if (arrayType.getBaseType()->isValueType())
 					CompilerUtils(m_context).loadFromMemoryDynamic(*arrayType.getBaseType(), true, true, false);
 				break;
 			case ArrayType::Location::Storage:
-				m_context << u256(0); // @todo
+				m_context << eth::Instruction::SWAP1;
+				if (arrayType.getBaseType()->getStorageBytes() <= 16)
+				{
+					// stack: <data_ref> <index>
+					// goal:
+					// <ref> <byte_number> = <base_ref + index / itemsPerSlot> <(index % itemsPerSlot) * byteSize>
+					unsigned byteSize = arrayType.getBaseType()->getStorageBytes();
+					solAssert(byteSize != 0, "");
+					unsigned itemsPerSlot = 32 / byteSize;
+					m_context << u256(itemsPerSlot) << eth::Instruction::SWAP2;
+					// stack: itemsPerSlot index data_ref
+					m_context
+						<< eth::Instruction::DUP3 << eth::Instruction::DUP3
+						<< eth::Instruction::DIV << eth::Instruction::ADD
+					// stack: itemsPerSlot index (data_ref + index / itemsPerSlot)
+						<< eth::Instruction::SWAP2 << eth::Instruction::SWAP1
+						<< eth::Instruction::MOD
+						<< u256(byteSize) << eth::Instruction::MUL;
+				}
+				else
+				{
+					if (arrayType.getBaseType()->getStorageSize() != 1)
+						m_context << arrayType.getBaseType()->getStorageSize() << eth::Instruction::MUL;
+					m_context << eth::Instruction::ADD << u256(0);
+				}
 				setLValueToStorageItem(_indexAccess);
 				break;
 			case ArrayType::Location::Memory:
diff --git a/libsolidity/Types.cpp b/libsolidity/Types.cpp
index 4b5dddacd..016f0b236 100644
--- a/libsolidity/Types.cpp
+++ b/libsolidity/Types.cpp
@@ -20,14 +20,14 @@
  * Solidity data types
  */
 
+#include <libsolidity/Types.h>
+#include <limits>
+#include <boost/range/adaptor/reversed.hpp>
 #include <libdevcore/CommonIO.h>
 #include <libdevcore/CommonData.h>
 #include <libsolidity/Utils.h>
-#include <libsolidity/Types.h>
 #include <libsolidity/AST.h>
 
-#include <limits>
-
 using namespace std;
 
 namespace dev
@@ -184,6 +184,8 @@ TypePointer Type::fromArrayTypeName(TypeName& _baseTypeName, Expression* _length
 	TypePointer baseType = _baseTypeName.toType();
 	if (!baseType)
 		BOOST_THROW_EXCEPTION(_baseTypeName.createTypeError("Invalid type name."));
+	if (baseType->getStorageBytes() == 0)
+		BOOST_THROW_EXCEPTION(_baseTypeName.createTypeError("Illegal base type of storage size zero for array."));
 	if (_length)
 	{
 		if (!_length->getType())
@@ -700,13 +702,21 @@ u256 ArrayType::getStorageSize() const
 {
 	if (isDynamicallySized())
 		return 1;
-	else
+
+	bigint size;
+	unsigned baseBytes = getBaseType()->getStorageBytes();
+	if (baseBytes == 0)
+		size = 1;
+	else if (baseBytes < 32)
 	{
-		bigint size = bigint(getLength()) * getBaseType()->getStorageSize();
-		if (size >= bigint(1) << 256)
-			BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Array too large for storage."));
-		return max<u256>(1, u256(size));
+		unsigned itemsPerSlot = 32 / baseBytes;
+		size = (bigint(getLength()) + (itemsPerSlot - 1)) / itemsPerSlot;
 	}
+	else
+		size = bigint(getLength()) * getBaseType()->getStorageSize();
+	if (size >= bigint(1) << 256)
+		BOOST_THROW_EXCEPTION(TypeError() << errinfo_comment("Array too large for storage."));
+	return max<u256>(1, u256(size));
 }
 
 unsigned ArrayType::getSizeOnStack() const
@@ -806,6 +816,26 @@ u256 ContractType::getFunctionIdentifier(string const& _functionName) const
 	return Invalid256;
 }
 
+vector<tuple<VariableDeclaration const*, u256, unsigned>> ContractType::getStateVariables() const
+{
+	vector<VariableDeclaration const*> variables;
+	for (ContractDefinition const* contract: boost::adaptors::reverse(m_contract.getLinearizedBaseContracts()))
+		for (ASTPointer<VariableDeclaration> const& variable: contract->getStateVariables())
+			if (!variable->isConstant())
+				variables.push_back(variable.get());
+	TypePointers types;
+	for (auto variable: variables)
+		types.push_back(variable->getType());
+	StorageOffsets offsets;
+	offsets.computeOffsets(types);
+
+	vector<tuple<VariableDeclaration const*, u256, unsigned>> variablesAndOffsets;
+	for (size_t index = 0; index < variables.size(); ++index)
+		if (auto const* offset = offsets.getOffset(index))
+			variablesAndOffsets.push_back(make_tuple(variables[index], offset->first, offset->second));
+	return variablesAndOffsets;
+}
+
 TypePointer StructType::unaryOperatorResult(Token::Value _operator) const
 {
 	return _operator == Token::Delete ? make_shared<VoidType>() : TypePointer();
diff --git a/libsolidity/Types.h b/libsolidity/Types.h
index e7601fde8..c90aabda1 100644
--- a/libsolidity/Types.h
+++ b/libsolidity/Types.h
@@ -335,13 +335,22 @@ public:
 
 	/// Constructor for a byte array ("bytes")
 	explicit ArrayType(Location _location):
-		m_location(_location), m_isByteArray(true), m_baseType(std::make_shared<IntegerType>(8)) {}
+		m_location(_location),
+		m_isByteArray(true),
+		m_baseType(std::make_shared<FixedBytesType>(8))
+	{}
 	/// Constructor for a dynamically sized array type ("type[]")
 	ArrayType(Location _location, const TypePointer &_baseType):
-		m_location(_location), m_baseType(_baseType) {}
+		m_location(_location),
+		m_baseType(_baseType)
+	{}
 	/// Constructor for a fixed-size array type ("type[20]")
 	ArrayType(Location _location, const TypePointer &_baseType, u256 const& _length):
-		m_location(_location), m_baseType(_baseType), m_hasDynamicLength(false), m_length(_length) {}
+		m_location(_location),
+		m_baseType(_baseType),
+		m_hasDynamicLength(false),
+		m_length(_length)
+	{}
 
 	virtual bool isImplicitlyConvertibleTo(Type const& _convertTo) const override;
 	virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
@@ -403,6 +412,10 @@ public:
 	/// not exist.
 	u256 getFunctionIdentifier(std::string const& _functionName) const;
 
+	/// @returns a list of all state variables (including inherited) of the contract and their
+	/// offsets in storage.
+	std::vector<std::tuple<VariableDeclaration const*, u256, unsigned>> getStateVariables() const;
+
 private:
 	ContractDefinition const& m_contract;
 	/// If true, it is the "super" type of the current contract, i.e. it contains only inherited
diff --git a/libweb3jsonrpc/WebThreeStubServerBase.cpp b/libweb3jsonrpc/WebThreeStubServerBase.cpp
index 76b422a18..6424354f2 100644
--- a/libweb3jsonrpc/WebThreeStubServerBase.cpp
+++ b/libweb3jsonrpc/WebThreeStubServerBase.cpp
@@ -476,7 +476,7 @@ string WebThreeStubServerBase::eth_call(Json::Value const& _json, string const&
 		t.gasPrice = 10 * dev::eth::szabo;
 	if (!t.gas)
 		t.gas = min<u256>(client()->gasLimitRemaining(), client()->balanceAt(t.from) / t.gasPrice);
-	ret = toJS(client()->call(m_accounts->secretKey(t.from), t.value, t.to, t.data, t.gas, t.gasPrice, number));
+	ret = toJS(client()->call(m_accounts->secretKey(t.from), t.value, t.to, t.data, t.gas, t.gasPrice, number).output);
 	
 	return ret;
 }
diff --git a/neth/main.cpp b/neth/main.cpp
index 2ce9872ca..5fa48dd7f 100644
--- a/neth/main.cpp
+++ b/neth/main.cpp
@@ -373,7 +373,7 @@ int main(int argc, char** argv)
 		{
 			try
 			{
-				coinbase = h160(fromHex(argv[++i], ThrowType::Throw));
+				coinbase = h160(fromHex(argv[++i], WhenError::Throw));
 			}
 			catch (BadHexCharacter& _e)
 			{
@@ -734,8 +734,8 @@ int main(int argc, char** argv)
 				{
 					try
 					{
-						Secret secret = h256(fromHex(sechex, ThrowType::Throw));
-						Address dest = h160(fromHex(fields[0], ThrowType::Throw));
+						Secret secret = h256(fromHex(sechex, WhenError::Throw));
+						Address dest = h160(fromHex(fields[0], WhenError::Throw));
 						c->submitTransaction(secret, amount, dest, data, gas, gasPrice);
 					}
 					catch (BadHexCharacter& _e)
@@ -786,7 +786,7 @@ int main(int argc, char** argv)
 					u256 minGas = (u256)Client::txGas(bytes(), 0);
 					try
 					{
-						Address dest = h160(fromHex(fields[0], ThrowType::Throw));
+						Address dest = h160(fromHex(fields[0], WhenError::Throw));
 						c->submitTransaction(us.secret(), amount, dest, bytes(), minGas);
 					}
 					catch (BadHexCharacter& _e)
@@ -852,7 +852,7 @@ int main(int argc, char** argv)
 					stringstream ssc;
 					try
 					{
-						init = fromHex(sinit, ThrowType::Throw);
+						init = fromHex(sinit, WhenError::Throw);
 					}
 					catch (BadHexCharacter& _e)
 					{
diff --git a/test/SolidityEndToEndTest.cpp b/test/SolidityEndToEndTest.cpp
index 0bd27a5fc..ea6ada603 100644
--- a/test/SolidityEndToEndTest.cpp
+++ b/test/SolidityEndToEndTest.cpp
@@ -3088,6 +3088,123 @@ BOOST_AUTO_TEST_CASE(array_copy_storage_storage_static_dynamic)
 	BOOST_CHECK(callContractFunction("test()") == encodeArgs(9, 4));
 }
 
+BOOST_AUTO_TEST_CASE(array_copy_different_packing)
+{
+	char const* sourceCode = R"(
+		contract c {
+			bytes8[] data1; // 4 per slot
+			bytes10[] data2; // 3 per slot
+			function test() returns (bytes10 a, bytes10 b, bytes10 c, bytes10 d, bytes10 e) {
+				data1.length = 9;
+				for (uint i = 0; i < data1.length; ++i)
+					data1[i] = bytes8(i);
+				data2 = data1;
+				a = data2[1];
+				b = data2[2];
+				c = data2[3];
+				d = data2[4];
+				e = data2[5];
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("test()") == encodeArgs(
+		asString(fromHex("0000000000000001")),
+		asString(fromHex("0000000000000002")),
+		asString(fromHex("0000000000000003")),
+		asString(fromHex("0000000000000004")),
+		asString(fromHex("0000000000000005"))
+	));
+}
+
+BOOST_AUTO_TEST_CASE(array_copy_target_simple)
+{
+	char const* sourceCode = R"(
+		contract c {
+			bytes8[9] data1; // 4 per slot
+			bytes17[10] data2; // 1 per slot, no offset counter
+			function test() returns (bytes17 a, bytes17 b, bytes17 c, bytes17 d, bytes17 e) {
+				for (uint i = 0; i < data1.length; ++i)
+					data1[i] = bytes8(i);
+				data2[8] = data2[9] = 2;
+				data2 = data1;
+				a = data2[1];
+				b = data2[2];
+				c = data2[3];
+				d = data2[4];
+				e = data2[9];
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("test()") == encodeArgs(
+		asString(fromHex("0000000000000001")),
+		asString(fromHex("0000000000000002")),
+		asString(fromHex("0000000000000003")),
+		asString(fromHex("0000000000000004")),
+		asString(fromHex("0000000000000000"))
+	));
+}
+
+BOOST_AUTO_TEST_CASE(array_copy_target_leftover)
+{
+	// test that leftover elements in the last slot of target are correctly cleared during assignment
+	char const* sourceCode = R"(
+		contract c {
+			byte[10] data1;
+			bytes2[32] data2;
+			function test() returns (uint check, uint res1, uint res2) {
+				uint i;
+				for (i = 0; i < data2.length; ++i)
+					data2[i] = 0xffff;
+				check = uint(data2[31]) * 0x10000 | uint(data2[14]);
+				for (i = 0; i < data1.length; ++i)
+					data1[i] = byte(uint8(1 + i));
+				data2 = data1;
+				for (i = 0; i < 16; ++i)
+					res1 |= uint(data2[i]) * 0x10000**i;
+				for (i = 0; i < 16; ++i)
+					res2 |= uint(data2[16 + i]) * 0x10000**i;
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("test()") == encodeArgs(
+		u256("0xffffffff"),
+		asString(fromHex("0000000000000000""000000000a000900""0800070006000500""0400030002000100")),
+		asString(fromHex("0000000000000000""0000000000000000""0000000000000000""0000000000000000"))
+	));
+}
+
+BOOST_AUTO_TEST_CASE(array_copy_target_leftover2)
+{
+	// since the copy always copies whole slots, we have to make sure that the source size maxes
+	// out a whole slot and at the same time there are still elements left in the target at that point
+	char const* sourceCode = R"(
+		contract c {
+			bytes8[4] data1; // fits into one slot
+			bytes10[6] data2; // 4 elements need two slots
+			function test() returns (bytes10 r1, bytes10 r2, bytes10 r3) {
+				data1[0] = 1;
+				data1[1] = 2;
+				data1[2] = 3;
+				data1[3] = 4;
+				for (uint i = 0; i < data2.length; ++i)
+					data2[i] = bytes10(0xffff00 | (1 + i));
+				data2 = data1;
+				r1 = data2[3];
+				r2 = data2[4];
+				r3 = data2[5];
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("test()") == encodeArgs(
+		asString(fromHex("0000000000000004")),
+		asString(fromHex("0000000000000000")),
+		asString(fromHex("0000000000000000"))
+	));
+}
 BOOST_AUTO_TEST_CASE(array_copy_storage_storage_struct)
 {
 	char const* sourceCode = R"(
@@ -3214,7 +3331,7 @@ BOOST_AUTO_TEST_CASE(array_copy_nested_array)
 	char const* sourceCode = R"(
 		contract c {
 			uint[4][] a;
-			uint[5][] b;
+			uint[10][] b;
 			uint[][] c;
 			function test(uint[2][] d) external returns (uint) {
 				a = d;
@@ -3480,6 +3597,30 @@ BOOST_AUTO_TEST_CASE(packed_storage_structs_delete)
 	BOOST_CHECK(m_state.storage(m_contractAddress).empty());
 }
 
+BOOST_AUTO_TEST_CASE(packed_storage_structs_with_bytes0)
+{
+	char const* sourceCode = R"(
+		contract C {
+			struct str { uint8 a; bytes0 b; uint8 c; }
+			uint8 a;
+			bytes0 x;
+			uint8 b;
+			str data;
+			function test() returns (bool) {
+				a = 2;
+				b = 3;
+				data.a = 4;
+				data.c = 5;
+				delete x;
+				delete data.b;
+				return a == 2 && b == 3 && data.a == 4 && data.c == 5;
+			}
+		}
+	)";
+	compileAndRun(sourceCode);
+	BOOST_CHECK(callContractFunction("test()") == encodeArgs(true));
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }
diff --git a/test/SolidityNameAndTypeResolution.cpp b/test/SolidityNameAndTypeResolution.cpp
index b83709d83..591cf053a 100644
--- a/test/SolidityNameAndTypeResolution.cpp
+++ b/test/SolidityNameAndTypeResolution.cpp
@@ -1446,6 +1446,16 @@ BOOST_AUTO_TEST_CASE(local_const_variable)
 	BOOST_CHECK_THROW(parseTextAndResolveNames(text), ParserError);
 }
 
+BOOST_AUTO_TEST_CASE(bytes0_array)
+{
+	char const* text = R"(
+		contract Foo {
+			bytes0[] illegalArray;
+		}
+	)";
+	BOOST_CHECK_THROW(parseTextAndResolveNames(text), TypeError);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }
diff --git a/test/SolidityTypes.cpp b/test/SolidityTypes.cpp
index 8defd1d89..6b6306479 100644
--- a/test/SolidityTypes.cpp
+++ b/test/SolidityTypes.cpp
@@ -75,6 +75,17 @@ BOOST_AUTO_TEST_CASE(storage_layout_mapping)
 	BOOST_CHECK(*members.getMemberStorageOffset("final") == make_pair(u256(3), unsigned(0)));
 }
 
+BOOST_AUTO_TEST_CASE(storage_layout_arrays)
+{
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(1), 32).getStorageSize() == 1);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(1), 33).getStorageSize() == 2);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(2), 31).getStorageSize() == 2);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(7), 8).getStorageSize() == 2);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(7), 9).getStorageSize() == 3);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(31), 9).getStorageSize() == 9);
+	BOOST_CHECK(ArrayType(ArrayType::Location::Storage, make_shared<FixedBytesType>(32), 9).getStorageSize() == 9);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }
diff --git a/test/TestHelper.cpp b/test/TestHelper.cpp
index 128318b8c..b29c5dc3a 100644
--- a/test/TestHelper.cpp
+++ b/test/TestHelper.cpp
@@ -240,7 +240,7 @@ byte toByte(json_spirit::mValue const& _v)
 
 bytes importByteArray(std::string const& _str)
 {
-	return fromHex(_str.substr(0, 2) == "0x" ? _str.substr(2) : _str, ThrowType::Throw);
+	return fromHex(_str.substr(0, 2) == "0x" ? _str.substr(2) : _str, WhenError::Throw);
 }
 
 bytes importData(json_spirit::mObject& _o)
diff --git a/test/blockchain.cpp b/test/blockchain.cpp
index 5ad395499..0f5eeaee2 100644
--- a/test/blockchain.cpp
+++ b/test/blockchain.cpp
@@ -653,9 +653,9 @@ BOOST_AUTO_TEST_CASE(bcUncleTest)
 	dev::test::executeTests("bcUncleTest", "/BlockTests", dev::test::doBlockchainTests);
 }
 
-BOOST_AUTO_TEST_CASE(userDefinedFileBc)
+BOOST_AUTO_TEST_CASE(userDefinedFile)
 {
-	dev::test::userDefinedTest("--bctest", dev::test::doBlockchainTests);
+	dev::test::userDefinedTest("--singletest", dev::test::doBlockchainTests);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/vmArithmeticTestFiller.json b/test/vmArithmeticTestFiller.json
index df3fa84f5..1af2964f6 100644
--- a/test/vmArithmeticTestFiller.json
+++ b/test/vmArithmeticTestFiller.json
@@ -925,6 +925,146 @@
         }
     },
 
+    "sdiv5": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : "1",
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : "0",
+            "code" : "{ [[ 0 ]] (SDIV (- 0 57896044618658097711785492504343953926634992332820282019728792003956564819968) (- 0 1) )  }",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "100000"
+        }
+    },
+
+   "sdiv6": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : "1",
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : "0",
+            "code" : "{ [[ 0 ]] (SDIV (- 0 57896044618658097711785492504343953926634992332820282019728792003956564819968) 0 )  }",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "100000"
+        }
+    },
+
+    "sdiv7": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : "1",
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : "0",
+            "code" : "{ [[ 0 ]] (SDIV (- 0 1) 25 )  }",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "100000"
+        }
+    },
+
+    "sdiv8": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : "1",
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : "0",
+            "code" : "{ [[ 0 ]] (SDIV (- 0 1) (- 0 1))  }",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "100000"
+        }
+    },
+
+    "sdiv9": {
+        "env" : {
+        "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
+        "currentNumber" : "0",
+        "currentGasLimit" : "1000000",
+        "currentDifficulty" : "256",
+        "currentTimestamp" : "1",
+        "currentCoinbase" : "2adc25665018aa1fe0e6bc666dac8fc2697ff9ba"
+        },
+        "pre" : {
+        "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6" : {
+            "balance" : "1000000000000000000",
+            "nonce" : "0",
+            "code" : "{ [[ 0 ]] (SDIV (- 0 1) 1)  }",
+            "storage": {}
+        }
+        },
+        "exec" : {
+            "address" : "0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6",
+            "origin" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "caller" : "cd1722f2947def4cf144679da39c4c32bdc35681",
+            "value" : "1000000000000000000",
+            "data" : "",
+            "gasPrice" : "100000000000000",
+            "gas" : "100000"
+        }
+    },
+
     "sdiv_i256min": {
         "env" : {
         "previousHash" : "5e20a0453cecd065ea59c37ac63e079ee08998b6045136a8ce6635c7912ec0b6",
@@ -977,7 +1117,7 @@
             "value" : "1000000000000000000",
             "data" : "",
             "gasPrice" : "100000000000000",
-            "gas" : "10000"
+            "gas" : "100000"
         }
     },