diff --git a/LedgerHistory.cpp b/LedgerHistory.cpp
index 2ae5ba12c1..a676d16d6e 100644
--- a/LedgerHistory.cpp
+++ b/LedgerHistory.cpp
@@ -11,7 +11,7 @@ void LedgerHistory::addLedger(Ledger::pointer ledger)
 {
 	uint256 h(ledger->getHash());
 	boost::recursive_mutex::scoped_lock sl(mLock);
-	if(!mLedgersByHash[h]) mLedgersByHash[h]=ledger;
+	if(!mLedgersByHash.count(h)) mLedgersByHash.insert(std::make_pair(h, ledger));
 }
 
 void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger)
@@ -19,44 +19,40 @@ void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger)
 	assert(ledger && ledger->isAccepted());
 	uint256 h(ledger->getHash());
 	boost::recursive_mutex::scoped_lock sl(mLock);
-	if(!!mLedgersByHash[h]) return;
-	mLedgersByHash[h]=ledger;
-	mLedgersByIndex[ledger->getLedgerSeq()]=ledger;
-
+	mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
+	mLedgersByHash.insert(std::make_pair(h, ledger));
 	theApp->getIOService().post(boost::bind(&Ledger::saveAcceptedLedger, ledger));
 }
 
 Ledger::pointer LedgerHistory::getLedgerBySeq(uint32 index)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
-	Ledger::pointer ret(mLedgersByIndex[index]);
-	if(ret) return ret;
+	if(mLedgersByIndex.count(index)) return mLedgersByIndex[index];
 	sl.unlock();
-	ret=Ledger::loadByIndex(index);
+	Ledger::pointer ret(Ledger::loadByIndex(index));
 	if(!ret) return ret;
 
 	assert(ret->getLedgerSeq()==index);
 	uint256 h=ret->getHash();
 	sl.lock();
-	mLedgersByIndex[index]=ret;
-	mLedgersByHash[h]=ret;
+	mLedgersByIndex.insert(std::make_pair(index, ret));
+	mLedgersByHash.insert(std::make_pair(h, ret));
 	return ret;
 }
 
 Ledger::pointer LedgerHistory::getLedgerByHash(const uint256& hash)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
-	Ledger::pointer ret(mLedgersByHash[hash]);
-	if(ret) return ret;
+	if(mLedgersByHash.count(hash)!=0) return mLedgersByHash[hash];
 
 	sl.unlock();
-	ret=Ledger::loadByHash(hash);
+	Ledger::pointer ret=Ledger::loadByHash(hash);
 	if(!ret) return ret;
 
 	assert(ret->getHash()==hash);
 	sl.lock();
-	mLedgersByHash[hash]=ret;
-	if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ret;
+	mLedgersByHash.insert(std::make_pair(hash, ret));
+	if(ret->isAccepted()) mLedgersByIndex.insert(std::make_pair(ret->getLedgerSeq(), ret));
 	return ret;
 }
 
@@ -65,12 +61,12 @@ Ledger::pointer LedgerHistory::canonicalizeLedger(Ledger::pointer ledger, bool s
 	uint256 h(ledger->getHash());
 
 	boost::recursive_mutex::scoped_lock sl(mLock);
-	Ledger::pointer ret(mLedgersByHash[h]);
-	if(ret) return ret;
+	if(mLedgersByHash.count(h)!=0) return mLedgersByHash[h];
 	if(!save) return ledger;
-	assert(ret->getHash()==h);
-	mLedgersByHash[h]=ledger;
-	if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ledger;
+
+	assert(ledger->getHash()==h);
+	mLedgersByHash.insert(std::make_pair(h, ledger));
+	if(ledger->isAccepted()) mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
 	return ledger;
 }
 
diff --git a/LedgerMaster.cpp b/LedgerMaster.cpp
index e8fa90f368..bf723f2a95 100644
--- a/LedgerMaster.cpp
+++ b/LedgerMaster.cpp
@@ -27,9 +27,9 @@ uint64 LedgerMaster::getBalance(std::string& addr)
 bool LedgerMaster::addHeldTransaction(Transaction::pointer transaction)
 {
 	boost::recursive_mutex::scoped_lock ml(mLock);
-	if(!mHeldTransactionsByID[transaction->getID()])
+	if(mHeldTransactionsByID.count(transaction->getID())==0)
 	{
-		mHeldTransactionsByID[transaction->getID()]=transaction;
+		mHeldTransactionsByID.insert(std::make_pair(transaction->getID(), transaction));
 		return true;
 	}
 	return false;
diff --git a/SHAMap.cpp b/SHAMap.cpp
index 6773e81318..798e65da9e 100644
--- a/SHAMap.cpp
+++ b/SHAMap.cpp
@@ -21,7 +21,7 @@ void SHAMap::dirtyUp(const uint256& id)
 	if(!leaf) throw SHAMapException(MissingNode);
 
 	uint256 hVal=leaf->getNodeHash();
-	if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf;
+	if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
 	if(!hVal)
 	{
 #ifdef ST_DEBUG
@@ -44,7 +44,7 @@ void SHAMap::dirtyUp(const uint256& id)
 #ifdef ST_DEBUG
 		std::cerr << "Dirty " << node->getString() << std::endl;
 #endif
-		if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node;
+		if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), node));
 		hVal=node->getNodeHash();
 		if(!hVal)
 		{
@@ -143,7 +143,7 @@ SHAMapInnerNode::pointer SHAMap::getInner(const SHAMapNode& id, const uint256& h
 	node=SHAMapInnerNode::pointer(new SHAMapInnerNode(id, rawNode, mSeq));
 	if(node->getNodeHash()!=hash) throw SHAMapException(InvalidNode);
 
-	mInnerNodeByID[id]=node;
+	mInnerNodeByID.insert(std::make_pair(id, node));
 	if(id.getDepth()==0) root=node;
 	return node;
 }
@@ -154,7 +154,7 @@ SHAMapLeafNode::pointer SHAMap::returnLeaf(SHAMapLeafNode::pointer leaf, bool mo
 	{
 		leaf=SHAMapLeafNode::pointer(new SHAMapLeafNode(*leaf, mSeq));
 		mLeafByID[*leaf]=leaf;
-		if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf;
+		if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
 	}
 	return leaf;
 }
@@ -167,8 +167,8 @@ SHAMapInnerNode::pointer SHAMap::returnNode(SHAMapInnerNode::pointer node, bool
 		std::cerr << "Node(" << node->getString() << ") bumpseq" << std::endl;
 #endif
 		node=SHAMapInnerNode::pointer(new SHAMapInnerNode(*node, mSeq));
-		mInnerNodeByID[*node]=node;
-		if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node;
+		mInnerNodeByID.insert(std::make_pair(SHAMapNode(*node), node));
+		if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), node));
 	}
 	return node;
 }
diff --git a/SHAMapDiff.cpp b/SHAMapDiff.cpp
index e0f9388b48..69c960493f 100644
--- a/SHAMapDiff.cpp
+++ b/SHAMapDiff.cpp
@@ -34,8 +34,8 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
 			 		SHAMapLeafNode::pointer thisNode=getLeaf(node.mNodeID, node.mOurHash, false);
 			 		for(SHAMapItem::pointer item=thisNode->firstItem(); item; item=thisNode->nextItem(item->getTag()))
 			 		{ // items in leaf only in our tree
-			 			differences[item->getTag()]=
-			 				std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(item, SHAMapItem::pointer());
+			 			differences.insert(std::make_pair(item->getTag(),
+			 				std::make_pair(item, SHAMapItem::pointer())));
 						if((--maxCount)<=0) return false;
 			 		}
 		 		}
@@ -44,8 +44,8 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
 			 		SHAMapLeafNode::pointer otherNode=otherMap->getLeaf(node.mNodeID, node.mOtherHash, false);
 			 		for(SHAMapItem::pointer item=otherNode->firstItem(); item; item=otherNode->nextItem(item->getTag()))
 			 		{ // items in leaf only in our tree
-			 			differences[item->getTag()]=
-			 				std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), item);
+			 			differences.insert(std::make_pair(item->getTag(),
+			 				std::make_pair(SHAMapItem::pointer(), item)));
 						if((--maxCount)<=0) return false;
 			 		}
 		 		}
@@ -59,24 +59,24 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
 			 		{
 			 			if(!otherItem)
 			 			{ // we have items, other tree does not
-			 				differences[ourItem->getTag()]=
-			 					std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
+			 				differences.insert(std::make_pair(ourItem->getTag(),
+			 					std::make_pair(ourItem, otherItem)));
 							if((--maxCount)<=0) return false;
 							otherItem=otherNode->nextItem(otherItem->getTag());
 			 			}
 			 			else if(!ourItem)
 			 			{ // we have no items, other tree does
-			 				differences[otherItem->getTag()]=
-			 					std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
+			 				differences.insert(std::make_pair(otherItem->getTag(),
+			 					std::make_pair(ourItem, otherItem)));
 							if((--maxCount)<=0) return false;
-							ourItem=thisNode->nextItem(ourItem->getTag());
+							otherItem=thisNode->nextItem(otherItem->getTag());
 			 			}
 			 			else if(ourItem->getTag()==otherItem->getTag())
 			 			{ // we have items with the same tag
 			 				if(ourItem->getData()!=otherItem->getData())
 			 				{ // different data
-				 				differences[ourItem->getTag()]=
-				 					std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
+			 					differences.insert(std::make_pair(ourItem->getTag(),
+			 						std::make_pair(ourItem, otherItem)));
 								if((--maxCount)<=0) return false;
 			 				}
 							ourItem=thisNode->nextItem(ourItem->getTag());
@@ -84,15 +84,15 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
 			 			}
 			 			else if(ourItem->getTag()<otherItem->getTag())
 			 			{ // our item comes first
-			 				differences[ourItem->getTag()]=
-			 					std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, SHAMapItem::pointer());
+			 				differences.insert(std::make_pair(ourItem->getTag(),
+			 					std::make_pair(ourItem, SHAMapItem::pointer())));
 							if((--maxCount)<=0) return false;
 							ourItem=thisNode->nextItem(ourItem->getTag());
 			 			}
 			 			else
 			 			{ // other item comes first
-			 				differences[otherItem->getTag()]=
-			 					std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), otherItem);
+			 				differences.insert(std::make_pair(otherItem->getTag(),
+			 					std::make_pair(SHAMapItem::pointer(), otherItem)));
 							if((--maxCount)<=0) return false;
 							otherItem=otherNode->nextItem(otherItem->getTag());
 			 			}