From 14cca75429733f59f7b3ca05ba730533bcd9046f Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Thu, 15 Feb 2018 21:35:00 -0800
Subject: [PATCH 1/7] server components of version of alternative versionstamp
 op that writes to an arbitrary place in the value

---
 fdbclient/Atomic.h                              | 17 ++++++++++++++++-
 fdbclient/CommitTransaction.h                   |  8 ++++----
 fdbclient/RYWIterator.h                         | 16 +++++++++++++++-
 fdbclient/ReadYourWrites.actor.cpp              | 13 ++++++++++++-
 fdbclient/WriteMap.h                            |  8 ++++----
 fdbserver/MasterProxyServer.actor.cpp           |  2 ++
 .../workloads/FuzzApiCorrectness.actor.cpp      | 16 +++++++++++-----
 fdbserver/workloads/Unreadable.actor.cpp        | 15 +++++++++++----
 fdbserver/workloads/VersionStamp.actor.cpp      | 14 +++++++++++++-
 9 files changed, 88 insertions(+), 21 deletions(-)

diff --git a/fdbclient/Atomic.h b/fdbclient/Atomic.h
index 105c9c9f8f4..70143a78e44 100644
--- a/fdbclient/Atomic.h
+++ b/fdbclient/Atomic.h
@@ -279,4 +279,19 @@ static void transformSetVersionstampedValue( MutationRef& mutation, Version vers
 	mutation.type = MutationRef::SetValue;
 }
 
-#endif
\ No newline at end of file
+static void transformSetVersionstampedValuePos( MutationRef& mutation, Version version, uint16_t transactionNumber ) {
+	if (mutation.param2.size() >= 4) {
+		int32_t pos;
+		memcpy(&pos, mutation.param2.end() - sizeof(int32_t), sizeof(int32_t));
+		pos = littleEndian32(pos);
+		mutation.param2 = mutation.param2.substr(0, mutation.param2.size() - 4);
+
+		if (pos >= 0 && pos + 10 <= mutation.param2.size()) {
+			placeVersionstamp( mutateString(mutation.param2) + pos, version, transactionNumber );
+		}
+	}
+
+	mutation.type = MutationRef::SetValue;
+}
+
+#endif
diff --git a/fdbclient/CommitTransaction.h b/fdbclient/CommitTransaction.h
index 8064849df19..911869bf252 100644
--- a/fdbclient/CommitTransaction.h
+++ b/fdbclient/CommitTransaction.h
@@ -24,11 +24,11 @@
 
 #include "FDBTypes.h"
 
-static const char * typeString[] = { "SetValue", "ClearRange", "AddValue", "DebugKeyRange", "DebugKey", "NoOp", "And", "Or", "Xor", "AppendIfFits", "AvailableForReuse", "Reserved_For_LogProtocolMessage", "Max", "Min", "SetVersionstampedKey", "SetVersionstampedValue", "ByteMin", "ByteMax", "MinV2", "AndV2" };
+static const char * typeString[] = { "SetValue", "ClearRange", "AddValue", "DebugKeyRange", "DebugKey", "NoOp", "And", "Or", "Xor", "AppendIfFits", "AvailableForReuse", "Reserved_For_LogProtocolMessage", "Max", "Min", "SetVersionstampedKey", "SetVersionstampedValue", "ByteMin", "ByteMax", "MinV2", "AndV2", "SetVersionstampedValuePos" };
 
 struct MutationRef { 
 	static const int OVERHEAD_BYTES = 12; //12 is the size of Header in MutationList entries
-	enum Type : uint8_t { SetValue=0, ClearRange, AddValue, DebugKeyRange, DebugKey, NoOp, And, Or, Xor, AppendIfFits, AvailableForReuse, Reserved_For_LogProtocolMessage /* See fdbserver/LogProtocolMessage.h */, Max, Min, SetVersionstampedKey, SetVersionstampedValue, ByteMin, ByteMax, MinV2, AndV2, MAX_ATOMIC_OP };
+	enum Type : uint8_t { SetValue=0, ClearRange, AddValue, DebugKeyRange, DebugKey, NoOp, And, Or, Xor, AppendIfFits, AvailableForReuse, Reserved_For_LogProtocolMessage /* See fdbserver/LogProtocolMessage.h */, Max, Min, SetVersionstampedKey, SetVersionstampedValue, ByteMin, ByteMax, MinV2, AndV2, SetVersionstampedValuePos, MAX_ATOMIC_OP };
 	// This is stored this way for serialization purposes.
 	uint8_t type;
 	StringRef param1, param2;
@@ -55,9 +55,9 @@ struct MutationRef {
 
 	// These masks define which mutation types have particular properties (they are used to implement isSingleKeyMutation() etc)
 	enum { 
-		ATOMIC_MASK = (1 << AddValue) | (1 << And) | (1 << Or) | (1 << Xor) | (1 << AppendIfFits) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << ByteMin) | (1 << ByteMax) | (1 << MinV2) | (1 << AndV2),
+		ATOMIC_MASK = (1 << AddValue) | (1 << And) | (1 << Or) | (1 << Xor) | (1 << AppendIfFits) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << ByteMin) | (1 << ByteMax) | (1 << MinV2) | (1 << AndV2) | (1 << SetVersionstampedValuePos),
 		SINGLE_KEY_MASK = ATOMIC_MASK | (1<<SetValue),
-		NON_ASSOCIATIVE_MASK = (1 << AddValue) | (1 << Or) | (1 << Xor) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << MinV2)
+		NON_ASSOCIATIVE_MASK = (1 << AddValue) | (1 << Or) | (1 << Xor) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << MinV2) | (1 << SetVersionstampedValuePos)
 	};
 };
 
diff --git a/fdbclient/RYWIterator.h b/fdbclient/RYWIterator.h
index 9d3d1fc5156..18e05d47ff7 100644
--- a/fdbclient/RYWIterator.h
+++ b/fdbclient/RYWIterator.h
@@ -85,6 +85,20 @@ class RandomTestImpl {
 		return ValueRef(arena, value);
 	}
 
+	static ValueRef getRandomVersionstampValuePos(Arena& arena) {
+		int len = g_random->randomInt(10, 98);
+		std::string value = std::string(len, 'x');
+		int pos = g_random->randomInt(0, len - 9);
+		if (g_random->random01() < 0.01) {
+			pos = value.size() - 10;
+		}
+		value += (char)(pos & 0xFF);
+		value += (char)((pos >> 8) & 0xFF);
+		value += (char)((pos >> 16) & 0xFF);
+		value += (char)((pos >> 24) & 0xFF);
+		return ValueRef(arena, value);
+	}
+
 	static ValueRef getRandomVersionstampKey(Arena& arena) {
 		int idx = g_random->randomInt(0, 100);
 		std::string key = format("%010d", idx / 3);
@@ -132,4 +146,4 @@ class RandomTestImpl {
 void testESR();
 void testSnapshotCache();
 
-#endif
\ No newline at end of file
+#endif
diff --git a/fdbclient/ReadYourWrites.actor.cpp b/fdbclient/ReadYourWrites.actor.cpp
index 5452215d941..b143b52c296 100644
--- a/fdbclient/ReadYourWrites.actor.cpp
+++ b/fdbclient/ReadYourWrites.actor.cpp
@@ -1423,6 +1423,7 @@ void ReadYourWritesTransaction::writeRangeToNativeTransaction( KeyRangeRef const
 					case MutationRef::Min:
 					case MutationRef::SetVersionstampedKey:
 					case MutationRef::SetVersionstampedValue:
+					case MutationRef::SetVersionstampedValuePos:
 					case MutationRef::ByteMin:
 					case MutationRef::ByteMax:
 					case MutationRef::MinV2:
@@ -1495,8 +1496,18 @@ void ReadYourWritesTransaction::atomicOp( const KeyRef& key, const ValueRef& ope
 		}
 	}
 
-	if (operationType == MutationRef::SetVersionstampedValue && operand.size() < 10)
+	if(operationType == MutationRef::SetVersionstampedValue && operand.size() < 10)
 		throw client_invalid_operation();
+
+	if(operationType == MutationRef::SetVersionstampedValuePos) {
+		if(operand.size() < 4)
+			throw client_invalid_operation();
+		int32_t pos;
+		memcpy(&pos, operand.end() - sizeof(int32_t), sizeof(int32_t));
+		pos = littleEndian32(pos);
+		if (pos < 0 || pos + 10 > operand.size() - 4)
+			throw client_invalid_operation();
+	}
 		
 	if (tr.apiVersionAtLeast(510)) {
 		if (operationType == MutationRef::Min)
diff --git a/fdbclient/WriteMap.h b/fdbclient/WriteMap.h
index 444ed750eb9..bb930c6aad9 100644
--- a/fdbclient/WriteMap.h
+++ b/fdbclient/WriteMap.h
@@ -65,7 +65,7 @@ class OperationStack {
 		bool isDependent() const {
 			if( !size() )
 				return false;
-			return singletonOperation.type != MutationRef::SetValue && singletonOperation.type != MutationRef::ClearRange && singletonOperation.type != MutationRef::SetVersionstampedValue && singletonOperation.type != MutationRef::SetVersionstampedKey;
+			return singletonOperation.type != MutationRef::SetValue && singletonOperation.type != MutationRef::ClearRange && singletonOperation.type != MutationRef::SetVersionstampedValue && singletonOperation.type != MutationRef::SetVersionstampedValuePos && singletonOperation.type != MutationRef::SetVersionstampedKey;
 		}
 		const RYWMutation& top() const { return hasVector() ? optionalOperations.get().back() : singletonOperation; }
 		RYWMutation& operator[] (int n) { return (n==0) ? singletonOperation : optionalOperations.get()[n-1]; }
@@ -142,8 +142,8 @@ class WriteMap {
 		bool following_conflict = it.entry().following_keys_conflict;
 		bool is_conflict = addConflict || it.is_conflict_range();
 		bool following_unreadable = it.entry().following_keys_unreadable;
-		bool is_unreadable = it.is_unreadable() || operation == MutationRef::SetVersionstampedValue || operation == MutationRef::SetVersionstampedKey;
-		bool is_dependent = operation != MutationRef::SetValue && operation != MutationRef::SetVersionstampedValue && operation != MutationRef::SetVersionstampedKey;
+		bool is_unreadable = it.is_unreadable() || operation == MutationRef::SetVersionstampedValue || operation == MutationRef::SetVersionstampedValuePos || operation == MutationRef::SetVersionstampedKey;
+		bool is_dependent = operation != MutationRef::SetValue && operation != MutationRef::SetVersionstampedValue && operation!= MutationRef::SetVersionstampedValuePos && operation != MutationRef::SetVersionstampedKey;
 
 		if (it.entry().key != key) {
 			if( it.is_cleared_range() && is_dependent ) {
@@ -630,4 +630,4 @@ class WriteMap {
 
 	*/
 
-#endif
\ No newline at end of file
+#endif
diff --git a/fdbserver/MasterProxyServer.actor.cpp b/fdbserver/MasterProxyServer.actor.cpp
index 1d8eaed1307..c8787c5a45f 100644
--- a/fdbserver/MasterProxyServer.actor.cpp
+++ b/fdbserver/MasterProxyServer.actor.cpp
@@ -248,6 +248,8 @@ struct ResolutionRequestBuilder {
 				trIn.write_conflict_ranges.push_back( requests[0].arena, singleKeyRange( m.param1, requests[0].arena ) );
 			} else if (m.type == MutationRef::SetVersionstampedValue ) {
 				transformSetVersionstampedValue( m, requests[0].version, transactionNumberInBatch );
+			} else if (m.type == MutationRef::SetVersionstampedValuePos ) {
+				transformSetVersionstampedValuePos( m, requests[0].version, transactionNumberInBatch );
 			}
 			if (isMetadataMutation(m)) {
 				isTXNStateTransaction = true;
diff --git a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
index 6804f94a2fb..61dce7ffeff 100644
--- a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
+++ b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
@@ -821,7 +821,8 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 		Key key;
 		Value value;
 		uint8_t op;
-		int16_t pos;
+		int16_t pos16;
+		int32_t pos32;
 
 		TestAtomicOp(unsigned int id, FuzzApiCorrectnessWorkload *workload) : BaseTestCallback(id, workload, "TestAtomicOp") {
 			key = makeKey();
@@ -853,9 +854,13 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 				op = g_random->randomInt(minval, maxval+1);
 			}
 
-			pos = -1;
+			pos16 = -1;
 			if(op == MutationRef::SetVersionstampedKey && key.size() >= 2) {
-				pos = littleEndian16(*(int16_t*)&key.end()[-2]);
+				pos16 = littleEndian16(*(int16_t*)&key.end()[-2]);
+			}
+			pos32 = -1;
+			if(op == MutationRef::SetVersionstampedValuePos && value.size() >= 4) {
+				pos32 = littleEndian32(*(int32_t*)&value.end()[-4]);
 			}
 
 			contract = {
@@ -867,7 +872,8 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 							(key >= (workload->useSystemKeys ? systemKeys.end : normalKeys.end))) ),
 				std::make_pair( error_code_client_invalid_operation, ExceptionContract::requiredIf(
 							(op == MutationRef::SetVersionstampedValue && value.size() < 10) ||
-							(op == MutationRef::SetVersionstampedKey && (pos < 0 || pos + 10 > key.size() - 2))) )
+							(op == MutationRef::SetVersionstampedKey && (pos16 < 0 || pos16 + 10 > key.size() - 2)) ||
+							(op == MutationRef::SetVersionstampedValuePos && (pos32 < 0 || pos32 + 10 > value.size() - 4))) )
 			};
 		}
 
@@ -877,7 +883,7 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 
 		void augmentTrace(TraceEvent &e) const {
 			base_type::augmentTrace(e);
-			e.detail("key", printable(key)).detail("value", printable(value)).detail("op", op).detail("pos", pos);
+			e.detail("key", printable(key)).detail("value", printable(value)).detail("op", op).detail("pos16", pos16).detail("pos32", pos32);
 		}
 	};
 
diff --git a/fdbserver/workloads/Unreadable.actor.cpp b/fdbserver/workloads/Unreadable.actor.cpp
index b9307b3140f..3e6653c6ef9 100644
--- a/fdbserver/workloads/Unreadable.actor.cpp
+++ b/fdbserver/workloads/Unreadable.actor.cpp
@@ -308,7 +308,7 @@ struct UnreadableWorkload : TestWorkload {
 			setMap[normalKeys.end] = ValueRef();
 
 			for (; opCount < 500; opCount++) {
-				int r = g_random->randomInt(0, 19);
+				int r = g_random->randomInt(0, 20);
 				if (r <= 10) {
 					key = RandomTestImpl::getRandomKey(arena);
 					value = RandomTestImpl::getRandomValue(arena);
@@ -341,6 +341,13 @@ struct UnreadableWorkload : TestWorkload {
 					//TraceEvent("RYWT_setVersionstampValue").detail("key", printable(key));
 				}
 				else if (r == 15) {
+					key = RandomTestImpl::getRandomKey(arena);
+					value = RandomTestImpl::getRandomVersionstampValuePos(arena);
+					tr.atomicOp(key, value, MutationRef::SetVersionstampedValuePos);
+					unreadableMap.insert(key, true);
+					//TraceEvent("RYWT_setVersionstampValuePos").detail("key", printable(key));
+				}
+				else if (r == 16) {
 					key = RandomTestImpl::getRandomVersionstampKey(arena);
 					value = RandomTestImpl::getRandomValue(arena);
 					tr.atomicOp(key, value, MutationRef::SetVersionstampedKey);
@@ -348,7 +355,7 @@ struct UnreadableWorkload : TestWorkload {
 					unreadableMap.insert(range, true);
 					//TraceEvent("RYWT_setVersionstampKey").detail("range", printable(range));
 				}
-				else if (r == 16) {
+				else if (r == 17) {
 					range = RandomTestImpl::getRandomRange(arena);
 					snapshot = g_random->random01() < 0.05;
 					reverse = g_random->random01() < 0.5;
@@ -378,7 +385,7 @@ struct UnreadableWorkload : TestWorkload {
 						setMap[normalKeys.end] = ValueRef();
 					}
 				}
-				else if (r == 17) {
+				else if (r == 18) {
 					begin = RandomTestImpl::getRandomKeySelector(arena);
 					end = RandomTestImpl::getRandomKeySelector(arena);
 					limit = g_random->randomInt(1, 100);   // maximum number of results to return from the db
@@ -425,7 +432,7 @@ struct UnreadableWorkload : TestWorkload {
 						setMap[normalKeys.end] = ValueRef();
 					}		
 				}
-				else if (r == 18) {
+				else if (r == 19) {
 					key = RandomTestImpl::getRandomKey(arena);
 					snapshot = g_random->random01() < 0.05;
 
diff --git a/fdbserver/workloads/VersionStamp.actor.cpp b/fdbserver/workloads/VersionStamp.actor.cpp
index b9af8d73daf..a59a214f57d 100644
--- a/fdbserver/workloads/VersionStamp.actor.cpp
+++ b/fdbserver/workloads/VersionStamp.actor.cpp
@@ -232,11 +232,23 @@ struct VersionStampWorkload : TestWorkload {
 			state KeyRangeRef range(prefix, endOfRange);
 			state Standalone<StringRef> committedVersionStamp;
 			state Version committedVersion;
+
+			bool useVersionstampPos = (g_random->random01() < 0.5);
+			state MutationRef::Type valueMutation;
+			state Value versionStampValue;
+			if(useVersionstampPos) {
+				versionStampValue = LiteralStringRef("\x00\x00\x00\x00").withPrefix(value);
+				valueMutation = MutationRef::SetVersionstampedValuePos;
+			} else {
+				versionStampValue = value;
+				valueMutation = MutationRef::SetVersionstampedValue;
+			}
+
 			loop{
 				state bool error = false;
 				//TraceEvent("VST_commit_begin").detail("key", printable(key)).detail("vsKey", printable(versionStampKey)).detail("clear", printable(range));
 				try {
-					tr.atomicOp(key, value, MutationRef::SetVersionstampedValue);
+					tr.atomicOp(key, versionStampValue, valueMutation);
 					tr.clear(range);
 					tr.atomicOp(versionStampKey, value, MutationRef::SetVersionstampedKey);
 					state Future<Standalone<StringRef>> fTrVs = tr.getVersionstamp();

From 2167012d83a716f3fcbb50bf5766dde043a914d7 Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Fri, 23 Feb 2018 18:17:53 -0800
Subject: [PATCH 2/7] use littleEndian16/32 instead of rolling our own

---
 fdbclient/RYWIterator.h | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/fdbclient/RYWIterator.h b/fdbclient/RYWIterator.h
index 18e05d47ff7..5bff2f63a8d 100644
--- a/fdbclient/RYWIterator.h
+++ b/fdbclient/RYWIterator.h
@@ -88,14 +88,12 @@ class RandomTestImpl {
 	static ValueRef getRandomVersionstampValuePos(Arena& arena) {
 		int len = g_random->randomInt(10, 98);
 		std::string value = std::string(len, 'x');
-		int pos = g_random->randomInt(0, len - 9);
+		int32_t pos = g_random->randomInt(0, len - 9);
 		if (g_random->random01() < 0.01) {
 			pos = value.size() - 10;
 		}
-		value += (char)(pos & 0xFF);
-		value += (char)((pos >> 8) & 0xFF);
-		value += (char)((pos >> 16) & 0xFF);
-		value += (char)((pos >> 24) & 0xFF);
+		pos = littleEndian32(pos);
+		value += std::string((const char*)&pos, sizeof(int32_t));
 		return ValueRef(arena, value);
 	}
 
@@ -106,15 +104,15 @@ class RandomTestImpl {
 			key += '\x00';
 		if (idx % 3 >= 2)
 			key += '\x00';
-		int pos = key.size() - g_random->randomInt(0, 3);
+		int16_t pos = key.size() - g_random->randomInt(0, 3);
 		if (g_random->random01() < 0.01) {
 			pos = 0;
 		}
 		key = key.substr(0, pos);
 		key += "XXXXXXXXYY";
 		key += std::string(g_random->randomInt(0, 3), 'z');
-		key += (char)(pos & 0xFF);
-		key += (char)((pos >> 8) & 0xFF);
+		pos = littleEndian16(pos);
+		key += std::string((const char*)&pos, sizeof(int16_t));
 		return ValueRef(arena, key);
 	}
 

From 6ee14bbb934ab06c82a9484d1e12ef262faef037 Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Fri, 2 Mar 2018 16:58:51 -0800
Subject: [PATCH 3/7] expose second versionstamp value type through
 vexillographer and add support in bindings and bindingtester

---
 bindings/bindingtester/tests/api.py           | 76 +++++++++++++-----
 bindings/flow/tester/Tester.actor.cpp         |  1 +
 .../apple/foundationdb/subspace/Subspace.java | 35 ++++++++-
 .../com/apple/foundationdb/tuple/Tuple.java   | 77 +++++++++++++++++--
 .../apple/foundationdb/tuple/TupleUtil.java   |  8 +-
 .../foundationdb/test/AsyncStackTester.java   |  9 ++-
 .../foundationdb/test/StackOperation.java     |  3 +-
 .../apple/foundationdb/test/StackTester.java  |  9 ++-
 .../test/VersionstampSmokeTest.java           |  2 +-
 bindings/python/fdb/tuple.py                  | 23 ++++--
 bindings/python/tests/tester.py               | 20 ++++-
 fdbclient/vexillographer/fdb.options          |  7 +-
 12 files changed, 226 insertions(+), 44 deletions(-)

diff --git a/bindings/bindingtester/tests/api.py b/bindings/bindingtester/tests/api.py
index e31b8636fbd..32cfee63243 100644
--- a/bindings/bindingtester/tests/api.py
+++ b/bindings/bindingtester/tests/api.py
@@ -40,6 +40,7 @@ def __init__(self, subspace):
         self.stack_subspace = self.subspace['stack']
 
         self.versionstamped_values = self.scratch['versionstamped_values']
+        self.versionstamped_values_2 = self.scratch['versionstamped_values_2']
         self.versionstamped_keys = self.scratch['versionstamped_keys']
 
     def setup(self, args):
@@ -150,7 +151,7 @@ def generate(self, args, thread_number):
         snapshot_versions = ['GET_READ_VERSION_SNAPSHOT']
         tuples = ['TUPLE_PACK', 'TUPLE_UNPACK', 'TUPLE_RANGE', 'TUPLE_SORT', 'SUB', 'ENCODE_FLOAT', 'ENCODE_DOUBLE', 'DECODE_DOUBLE', 'DECODE_FLOAT']
         if 'versionstamp' in args.types:
-            tuples.append('TUPLE_PACK_WITH_VERSIONSTAMP')
+            tuples += ['TUPLE_PACK_VERSIONSTAMPED_KEY', 'TUPLE_PACK_VERSIONSTAMPED_VALUE']
         resets = ['ON_ERROR', 'RESET', 'CANCEL']
         read_conflicts = ['READ_CONFLICT_RANGE', 'READ_CONFLICT_KEY']
         write_conflicts = ['WRITE_CONFLICT_RANGE', 'WRITE_CONFLICT_KEY', 'DISABLE_WRITE_CONFLICT']
@@ -349,17 +350,27 @@ def generate(self, args, thread_number):
             elif op == 'VERSIONSTAMP':
                 rand_str1 = self.random.random_string(100)
                 key1 = self.versionstamped_values.pack((rand_str1,))
+                key2 = self.versionstamped_values_2.pack((rand_str1,))
 
                 split = random.randint(0, 70)
-                rand_str2 = self.random.random_string(20 + split) + fdb.tuple.Versionstamp._UNSET_TR_VERSION + self.random.random_string(70 - split)
-                key2 = self.versionstamped_keys.pack() + rand_str2
-                index = key2.find(fdb.tuple.Versionstamp._UNSET_TR_VERSION)
-                key2 += chr(index % 256) + chr(index / 256)
+                prefix = self.random.random_string(20 + split)
+                if prefix.endswith('\xff'):
+                    # Necessary to make sure that the SET_VERSIONSTAMPED_VALUE check
+                    # correctly finds where the version is supposed to fit in.
+                    prefix += '\x00'
+                suffix = self.random.random_string(70 - split)
+                rand_str2 = prefix + fdb.tuple.Versionstamp._UNSET_TR_VERSION + suffix
+                key3 = self.versionstamped_keys.pack() + rand_str2
+                index = len(self.versionstamped_keys.pack()) + len(prefix)
+                key3 += chr(index % 256) + chr(index / 256)
 
                 instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', key1, fdb.tuple.Versionstamp._UNSET_TR_VERSION + rand_str2)
                 instructions.append('ATOMIC_OP')
 
-                instructions.push_args(u'SET_VERSIONSTAMPED_KEY', key2, rand_str1)
+                instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS', key2, rand_str2 + struct.pack('<L', len(prefix)))
+                instructions.append('ATOMIC_OP')
+
+                instructions.push_args(u'SET_VERSIONSTAMPED_KEY', key3, rand_str1)
                 instructions.append('ATOMIC_OP')
                 self.can_use_key_selectors = False
 
@@ -428,25 +439,42 @@ def generate(self, args, thread_number):
                 else:
                     self.add_strings(2)
 
-            elif op == 'TUPLE_PACK_WITH_VERSIONSTAMP':
+            elif op == 'TUPLE_PACK_VERSIONSTAMPED_KEY' or op == 'TUPLE_PACK_VERSIONSTAMPED_VALUE':
                 tup = (self.random.random_string(20),) + self.random.random_tuple(10, incomplete_versionstamps=True)
-                instructions.push_args(self.versionstamped_keys.pack(), len(tup), *tup)
+                prefix = self.versionstamped_keys.pack() if op == 'TUPLE_PACK_VERSIONSTAMPED_KEY' else ''
+                instructions.push_args(prefix, len(tup), *tup)
                 instructions.append(op)
                 self.add_strings(1)
 
-                version_key = self.versionstamped_keys.pack(tup)
-                first_incomplete = version_key.find(fdb.tuple.Versionstamp._UNSET_TR_VERSION)
+                versionstamp_param = prefix + fdb.tuple.pack(tup)
+                first_incomplete = versionstamp_param.find(fdb.tuple.Versionstamp._UNSET_TR_VERSION)
                 second_incomplete = -1 if first_incomplete < 0 else \
-                    version_key.find(fdb.tuple.Versionstamp._UNSET_TR_VERSION, first_incomplete + len(fdb.tuple.Versionstamp._UNSET_TR_VERSION) + 1)
+                    versionstamp_param.find(fdb.tuple.Versionstamp._UNSET_TR_VERSION, first_incomplete + len(fdb.tuple.Versionstamp._UNSET_TR_VERSION) + 1)
 
-                # If there is exactly one incomplete versionstamp, perform the versionstamped key operation.
+                # If there is exactly one incomplete versionstamp, perform the versionstamp operation.
                 if first_incomplete >= 0 and second_incomplete < 0:
                     rand_str = self.random.random_string(100)
 
-                    instructions.push_args(rand_str)
-                    test_util.to_front(instructions, 1)
-                    instructions.push_args(u'SET_VERSIONSTAMPED_KEY')
-                    instructions.append('ATOMIC_OP')
+                    if op == 'TUPLE_PACK_VERSIONSTAMPED_KEY':
+                        instructions.push_args(rand_str)
+                        test_util.to_front(instructions, 1)
+                        instructions.push_args(u'SET_VERSIONSTAMPED_KEY')
+                        instructions.append('ATOMIC_OP')
+
+                        version_value_key_2 = self.versionstamped_values_2.pack((rand_str,))
+                        versionstamped_value = fdb.tuple.pack(tup) + struct.pack('<L', first_incomplete - len(prefix))
+                        instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS', version_value_key_2, versionstamped_value)
+                        instructions.append('ATOMIC_OP')
+
+                    else:
+                        instructions.push_args(self.versionstamped_values_2.pack((rand_str,)))
+                        instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS')
+                        instructions.append('ATOMIC_OP')
+
+                        versionstamped_key = self.versionstamped_keys.pack() + versionstamp_param \
+                            + struct.pack('<H', first_incomplete + len(self.versionstamped_keys.pack()))
+                        instructions.push_args(u'SET_VERSIONSTAMPED_KEY', versionstamped_key, rand_str)
+                        instructions.append('ATOMIC_OP')
 
                     version_value_key = self.versionstamped_values.pack((rand_str,))
                     instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', version_value_key,
@@ -539,11 +567,19 @@ def check_versionstamps(self, tr, begin_key, limit):
         incorrect_versionstamps = 0
         for k, v in tr.get_range(begin_key, self.versionstamped_values.range().stop, limit=limit):
             next_begin = k + '\x00'
-            tup = fdb.tuple.unpack(k)
-            key = self.versionstamped_keys.pack() + v[10:].replace(fdb.tuple.Versionstamp._UNSET_TR_VERSION, v[:10], 1)
-            if tr[key] != tup[-1]:
+            random_id = self.versionstamped_values.unpack(k)[0]
+            versioned_value = v[10:].replace(fdb.tuple.Versionstamp._UNSET_TR_VERSION, v[:10], 1)
+
+            versioned_key = self.versionstamped_keys.pack() + versioned_value
+            if tr[versioned_key] != random_id:
+                util.get_logger().error('  INCORRECT VERSIONSTAMP:')
+                util.get_logger().error('    %s != %s', repr(tr[versioned_key]), repr(random_id))
+                incorrect_versionstamps += 1
+
+            k2 = self.versionstamped_values_2.pack((random_id,))
+            if tr[k2] != versioned_value:
                 util.get_logger().error('  INCORRECT VERSIONSTAMP:')
-                util.get_logger().error('    %s != %s', repr(tr[key]), repr(tup[-1]))
+                util.get_logger().error('    %s != %s', repr(tr[k2]), repr(versioned_value))
                 incorrect_versionstamps += 1
 
         return (next_begin, incorrect_versionstamps)
diff --git a/bindings/flow/tester/Tester.actor.cpp b/bindings/flow/tester/Tester.actor.cpp
index 7138c314c9f..5c63065b0d9 100644
--- a/bindings/flow/tester/Tester.actor.cpp
+++ b/bindings/flow/tester/Tester.actor.cpp
@@ -1676,6 +1676,7 @@ void populateAtomicOpMap() {
 	optionInfo["MIN"] = FDBMutationType::FDB_MUTATION_TYPE_MIN;
 	optionInfo["SET_VERSIONSTAMPED_KEY"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_KEY;
 	optionInfo["SET_VERSIONSTAMPED_VALUE"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_VALUE;
+	optionInfo["SET_VERSIONSTAMPED_VALUE_POS"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_VALUE_POS;
 	optionInfo["BYTE_MIN"] = FDBMutationType::FDB_MUTATION_TYPE_BYTE_MIN;
 	optionInfo["BYTE_MAX"] = FDBMutationType::FDB_MUTATION_TYPE_BYTE_MAX;
 }
diff --git a/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java b/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
index 26bc34177e7..e962d60b8e2 100644
--- a/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
+++ b/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
@@ -199,6 +199,23 @@ public byte[] pack(Tuple tuple) {
 		return tuple.pack(rawPrefix);
 	}
 
+	/**
+	 * Deprecated. Use {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} instead. Because
+	 * the serialization formats are different for versionstamped keys and values, this method was
+	 * deprecated to encourage developers to choose appropriately between
+	 * {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} and
+	 * {@link #packVersionstampedValue(Tuple)} packVersionstampedValue()}.
+	 *
+	 * @param tuple the {@code Tuple} to be packed
+	 * @return the key encoding the specified tuple in this {@code Subspace}
+	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
+	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedKey(Tuple) packVersionstampedKey()}
+	 */
+	@Deprecated
+	public byte[] packWithVersionstamp(Tuple tuple) {
+		return packVersionstampedKey(tuple);
+	}
+
 	/**
 	 * Gets the key encoding the specified tuple in this {@code Subspace} for use with
 	 * {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_KEY MutationType.SET_VERSIONSTAMPED_KEY}.
@@ -213,8 +230,22 @@ public byte[] pack(Tuple tuple) {
 	 * @return the key encoding the specified tuple in this {@code Subspace}
 	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
 	 */
-	public byte[] packWithVersionstamp(Tuple tuple) {
-		return tuple.packWithVersionstamp(rawPrefix);
+	public byte[] packVersionstampedKey(Tuple tuple) {
+		return tuple.packVersionstampedKey(rawPrefix);
+	}
+
+	/**
+	 * Gets the key encoding the specified tuple in this {@code Subspace} for use with
+	 * {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE MutationType.SET_VERSIONSTAMPED_VALUE}.
+	 * This works just like {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} except that
+	 * the final serialization format is different.
+	 *
+	 * @param tuple the {@code Tuple} to be packed
+	 * @return the key encoding the specified tuple in this {@code Subspace}
+	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
+	 */
+	public byte[] packVersionstampedValue(Tuple tuple) {
+		return tuple.packVersionstampedValue(rawPrefix);
 	}
 
 	/**
diff --git a/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java b/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
index 0886cc6fe48..65c46078fdc 100644
--- a/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
+++ b/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
@@ -302,17 +302,50 @@ public byte[] pack(byte[] prefix) {
 		return TupleUtil.pack(elements, prefix);
 	}
 
+	/**
+	 * Deprecated. Use {@link #packVersionstampedKey() packVersionstampedKey()} instead. Because
+	 *  versionstamped keys and versionstamped values are serialized differently, this method was deprecated
+	 *  to encourage developers to choose appropriately between
+	 *  {@link #packVersionstampedKey() packVersionstampedKey()} and
+	 *  {@link #packVersionstampedValue() packVersionstampedValue}.
+	 *
+	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
+	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
+	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedKey() packVersionstampedKey()}
+	 */
+	@Deprecated
+	public byte[] packWithVersionstamp() {
+		return packWithVersionstamp(null);
+	}
+
+	/**
+	 * Deprecated. Use {@link #packVersionstampedKey(byte[]) packVersionstampedKey()} instead. Because
+	 *  versionstamped keys and versionstamped values are serialized differently, this method was deprecated
+	 *  to encourage developers to choose appropriately between
+	 *  {@link #packVersionstampedKey(byte[]) packVersionstampedKey()} and
+	 *  {@link #packVersionstampedValue(byte[]) packVersionstampedValue}.
+	 *
+	 * @param prefix additional byte-array prefix to prepend to serialized bytes.
+	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
+	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
+	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedValue(byte[]) packVersionstampedKey()}
+	 */
+	@Deprecated
+	public byte[] packWithVersionstamp(byte[] prefix) {
+		return packVersionstampedKey(prefix);
+	}
+
 	/**
 	 * Get an encoded representation of this {@code Tuple} for use with
 	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_KEY MutationType.SET_VERSIONSTAMPED_KEY}.
-	 *  This works the same as the {@link #packWithVersionstamp(byte[]) one-paramter version of this method},
+	 *  This works the same as the {@link #packVersionstampedKey(byte[]) one-paramter version of this method},
 	 *  but it does not add any prefix to the array.
 	 *
 	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
 	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
 	 */
-	public byte[] packWithVersionstamp() {
-		return packWithVersionstamp(null);
+	public byte[] packVersionstampedKey() {
+		return packVersionstampedKey(null);
 	}
 
 	/**
@@ -332,8 +365,42 @@ public byte[] packWithVersionstamp() {
 	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
 	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
 	 */
-	public byte[] packWithVersionstamp(byte[] prefix) {
-		return TupleUtil.packWithVersionstamp(elements, prefix);
+	public byte[] packVersionstampedKey(byte[] prefix) {
+		return TupleUtil.packWithVersionstamp(elements, prefix, false);
+	}
+
+	/**
+	 * Get an encoded representation of this {@code Tuple} for use with
+	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE_POS MutationType.SET_VERSIONSTAMPED_VALUE_POS}.
+	 *  This works the same as the {@link #packVersionstampedValue(byte[]) one-paramter version of this method},
+	 *  but it does not add any prefix to the array.
+	 *
+	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
+	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
+	 */
+	public byte[] packVersionstampedValue() {
+		return packVersionstampedValue(null);
+	}
+
+	/**
+	 * Get an encoded representation of this {@code Tuple} for use with
+	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE_POS MutationType.SET_VERSIONSTAMPED_VALUE_POS}.
+	 *  There must be exactly one incomplete {@link Versionstamp} instance within this
+	 *  {@code Tuple} or this will throw an {@link IllegalArgumentException}.
+	 *  Each element is encoded to {@code byte}s and concatenated, the prefix
+	 *  is then prepended to the array, and then the index of the serialized incomplete
+	 *  {@link Versionstamp} is appended as a little-endian integer. This can then be passed
+	 *  as the value to
+	 *  {@link com.apple.foundationdb.Transaction#mutate(com.apple.foundationdb.MutationType, byte[], byte[]) Transaction.mutate()}
+	 *  with the {@code SET_VERSIONSTAMPED_VALUE_POS} {@link com.apple.foundationdb.MutationType}, and the transaction's
+	 *  version will then be filled in at commit time.
+	 *
+	 * @param prefix additional byte-array prefix to prepend to serialized bytes.
+	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
+	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
+	 */
+	public byte[] packVersionstampedValue(byte[] prefix) {
+		return TupleUtil.packWithVersionstamp(elements, prefix, true);
 	}
 
 	/**
diff --git a/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java b/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
index 73291ed784f..3316044dd1d 100644
--- a/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
+++ b/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
@@ -578,7 +578,7 @@ static byte[] pack(List<Object> items, byte[] prefix) {
 		}
 	}
 
-	static byte[] packWithVersionstamp(List<Object> items, byte[] prefix) {
+	static byte[] packWithVersionstamp(List<Object> items, byte[] prefix, boolean forValue) {
 		List<byte[]> encoded = new ArrayList<byte[]>(2 * items.size() + (prefix == null ? 1 : 2));
 		EncodeResult result = encodeAll(items, prefix, encoded);
 		if(result.versionPos < 0) {
@@ -587,7 +587,11 @@ static byte[] packWithVersionstamp(List<Object> items, byte[] prefix) {
 			if(result.versionPos > 0xffff) {
 				throw new IllegalArgumentException("Tuple has incomplete version at position " + result.versionPos + " which is greater than the maximum " + 0xffff);
 			}
-			encoded.add(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort((short)result.versionPos).array());
+			if (forValue) {
+				encoded.add(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(result.versionPos).array());
+			} else {
+				encoded.add(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort((short)result.versionPos).array());
+			}
 			return ByteArrayUtil.join(null, encoded);
 		}
 	}
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java b/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
index a81df36a73a..990791c668e 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
@@ -360,7 +360,7 @@ else if(op == StackOperation.TUPLE_PACK) {
 				}, FDB.DEFAULT_EXECUTOR);
 			}, FDB.DEFAULT_EXECUTOR);
 		}
-		else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
+		else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_VALUE) {
 			return inst.popParams(2).thenComposeAsync(params -> {
 				byte[] prefix = (byte[])params.get(0);
 				int tupleSize = StackUtils.getInt(params.get(1));
@@ -372,7 +372,12 @@ else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
 						return;
 					}
 					try {
-						byte[] coded = tuple.packWithVersionstamp(prefix);
+						byte[] coded;
+						if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY) {
+							coded = tuple.packVersionstampedKey(prefix);
+						} else {
+							coded = tuple.packVersionstampedValue(prefix);
+						}
 						inst.push("OK".getBytes());
 						inst.push(coded);
 					} catch(IllegalArgumentException e) {
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java b/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
index 7fdc7b9ff5c..894fa3d4f25 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
@@ -60,7 +60,8 @@ enum StackOperation {
 	SUB,
 	CONCAT,
 	TUPLE_PACK,
-	TUPLE_PACK_WITH_VERSIONSTAMP,
+	TUPLE_PACK_VERSIONSTAMPED_KEY,
+	TUPLE_PACK_VERSIONSTAMPED_VALUE,
 	TUPLE_UNPACK,
 	TUPLE_RANGE,
 	TUPLE_SORT,
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java b/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
index 2367c1fdc08..9374c0d4d06 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
@@ -321,7 +321,7 @@ else if(op == StackOperation.TUPLE_PACK) {
 				//System.out.println(inst.context.preStr + " - " + " -> result '" + ByteArrayUtil.printable(coded) + "'");
 				inst.push(coded);
 			}
-			else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
+			else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_VALUE) {
 				List<Object> params = inst.popParams(2).join();
 				byte[] prefix = (byte[])params.get(0);
 				int tupleSize = StackUtils.getInt(params.get(1));
@@ -331,7 +331,12 @@ else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
 					inst.push("ERROR: NONE".getBytes());
 				} else {
 					try {
-						byte[] coded = tuple.packWithVersionstamp(prefix);
+						byte[] coded;
+						if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY) {
+							coded = tuple.packVersionstampedKey(prefix);
+						} else {
+							coded = tuple.packVersionstampedValue(prefix);
+						}
 						inst.push("OK".getBytes());
 						inst.push(coded);
 					} catch (IllegalArgumentException e) {
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java b/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
index 556e92085e8..9c6358d3756 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
@@ -42,7 +42,7 @@ public static void main(String[] args) {
 			CompletableFuture<byte[]> trVersionFuture = db.run((Transaction tr) -> {
 				// The incomplete Versionstamp will have tr's version information when committed.
 				Tuple t = Tuple.from("prefix", Versionstamp.incomplete());
-				tr.mutate(MutationType.SET_VERSIONSTAMPED_KEY, t.packWithVersionstamp(), new byte[0]);
+				tr.mutate(MutationType.SET_VERSIONSTAMPED_KEY, t.packVersionstampedKey(), new byte[0]);
 				return tr.getVersionstamp();
 			});
 
diff --git a/bindings/python/fdb/tuple.py b/bindings/python/fdb/tuple.py
index 766e6590852..52237f6accf 100644
--- a/bindings/python/fdb/tuple.py
+++ b/bindings/python/fdb/tuple.py
@@ -374,7 +374,7 @@ def _encode(value, nested=False):
 #  * if there is exactly one incomplete versionstamp member, it returns the tuple with the
 #    two extra version bytes and the position of the version start
 #  * if there is more than one incomplete versionstamp member, it throws an error
-def _pack_maybe_with_versionstamp(t, prefix=None):
+def _pack_maybe_with_versionstamp(t, prefix=None, for_value=False):
     if not isinstance(t, tuple):
         raise Exception("fdbtuple pack() expects a tuple, got a " + str(type(t)))
 
@@ -384,7 +384,10 @@ def _pack_maybe_with_versionstamp(t, prefix=None):
     if version_pos >= 0:
         version_pos += len(prefix) if prefix is not None else 0
         bytes_list.extend(child_bytes)
-        bytes_list.append(struct.pack('<H', version_pos))
+        if for_value:
+            bytes_list.append(struct.pack('<L', version_pos))
+        else:
+            bytes_list.append(struct.pack('<H', version_pos))
     else:
         bytes_list.extend(child_bytes)
 
@@ -399,14 +402,24 @@ def pack(t, prefix=None):
     return res
 
 
-# packs the specified tuple into a key for versionstamp operations
-def pack_with_versionstamp(t, prefix=None):
-    res, version_pos = _pack_maybe_with_versionstamp(t, prefix)
+# packs the specified tuple into a key or value for versionstamp operations
+def pack_with_versionstamp(t, prefix=None, for_value=False):
+    res, version_pos = _pack_maybe_with_versionstamp(t, prefix=prefix, for_value=for_value)
     if version_pos < 0:
         raise ValueError("No incomplete versionstamp included in tuple pack with versionstamp")
     return res
 
 
+# packs the specified tuple into a key for versionstamp operations
+def pack_versionstamped_key(t, prefix=None):
+    return pack_with_versionstamp(t, prefix, for_value=False)
+
+
+# packs the specified tuple into a value for versionstamp operations
+def pack_versionstamped_value(t, prefix=None):
+    return pack_with_versionstamp(t, prefix, for_value=True)
+
+
 # unpacks the specified key into a tuple
 def unpack(key, prefix_len=0):
     pos = prefix_len
diff --git a/bindings/python/tests/tester.py b/bindings/python/tests/tester.py
index 9e9b20a3767..70e99d3ee36 100644
--- a/bindings/python/tests/tester.py
+++ b/bindings/python/tests/tester.py
@@ -467,7 +467,7 @@ def run(self):
                     count = inst.pop()
                     items = inst.pop(count)
                     inst.push(fdb.tuple.pack(tuple(items)))
-                elif inst.op == six.u("TUPLE_PACK_WITH_VERSIONSTAMP"):
+                elif inst.op == six.u("TUPLE_PACK_VERSIONSTAMPED_KEY"):
                     prefix = inst.pop()
                     count = inst.pop()
                     items = inst.pop(count)
@@ -475,7 +475,23 @@ def run(self):
                         inst.push(b"ERROR: NONE")
                     else:
                         try:
-                            packed = fdb.tuple.pack_with_versionstamp(tuple(items), prefix=prefix)
+                            packed = fdb.tuple.pack_versionstamped_key(tuple(items), prefix=prefix)
+                            inst.push(b"OK")
+                            inst.push(packed)
+                        except ValueError as e:
+                            if str(e).startswith("No incomplete"):
+                                inst.push(b"ERROR: NONE")
+                            else:
+                                inst.push(b"ERROR: MULTIPLE")
+                elif inst.op == six.u("TUPLE_PACK_VERSIONSTAMPED_VALUE"):
+                    prefix = inst.pop()
+                    count = inst.pop()
+                    items = inst.pop(count)
+                    if not fdb.tuple.has_incomplete_versionstamp(items) and random.random() < 0.5:
+                        inst.push(b"ERROR: NONE")
+                    else:
+                        try:
+                            packed = fdb.tuple.pack_versionstamped_value(tuple(items), prefix=prefix)
                             inst.push(b"OK")
                             inst.push(packed)
                         except ValueError as e:
diff --git a/fdbclient/vexillographer/fdb.options b/fdbclient/vexillographer/fdb.options
index 98950981dc6..31ccf221cf8 100644
--- a/fdbclient/vexillographer/fdb.options
+++ b/fdbclient/vexillographer/fdb.options
@@ -230,16 +230,19 @@ description is not currently required but encouraged.
             description="Performs a little-endian comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored in the database. If the existing value in the database is shorter than ``param``, it is first extended to the length of ``param`` with zero bytes.  If ``param`` is shorter than the existing value in the database, the existing value is truncated to match the length of ``param``. The smaller of the two values is then stored in the database."/>
     <Option name="set_versionstamped_key" code="14"
             paramType="Bytes" paramDescription="value to which to set the transformed key"
-            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database. The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Note that this implies versionstamped keys may not be used with the Subspace and Directory layers except in those languages." />
+            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final two bytes from the key and reading those as a little-Endian 16-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0, and note that this strips the final two bytes fromt the end of the key, in contrast to versionstamp value operations, which either replace the first 10 bytes or strip the last four bytes, depending on the variant used. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamps are compatible with the Tuple layer only in the Java and Python bindings. They are also not currently compatible with the Subspace and Directory layer except in those languages and only in instances where they have already been set." />
     <Option name="set_versionstamped_value" code="15"
             paramType="Bytes" paramDescription="value to versionstamp and set"
-            description="Transforms ``param`` using a versionstamp for the transaction. Sets ``key`` in the database to the transformed parameter. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database. The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are not compatible with the Tuple layer." />
+            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by replacing the first 10 bytes of the value with the versionstamp of the transaction used. Note that this does not let the user insert a versionstamp at an arbitrary place in the value, in contrast to versionstamp key operations. This can be done using the other versionstamp value variant. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are not compatible with the Tuple layer." />
     <Option name="byte_min" code="16"
             paramType="Bytes" paramDescription="value to check against database value"
             description="Performs lexicographic comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored. Otherwise the smaller of the two values is then stored in the database."/>
     <Option name="byte_max" code="17"
             paramType="Bytes" paramDescription="value to check against database value"
             description="Performs lexicographic comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored. Otherwise the larger of the two values is then stored in the database."/>
+    <Option name="set_versionstamped_value_pos" code="20"
+            paramType="Bytes" paramDescription="value to versionstamp and set"
+            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0, and note that this strips the final four bytes from the end of parameter, in contrast to versionstamp key operations, which only strip the two bytes. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are compatible with the Tuple layer only in the Java and Python bindings." />
   </Scope>
 
   <Scope name="ConflictRangeType">

From 464e2cdbf0ba9cffb63905684ff98213711f796a Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Wed, 21 Mar 2018 18:58:19 -0700
Subject: [PATCH 4/7] change SetVersionstampedKey and SetVersionstampedValue
 behavior based on API version to make them consistent

---
 fdbclient/Atomic.h                            | 48 +++++--------------
 fdbclient/CommitTransaction.h                 |  8 ++--
 fdbclient/ManagementAPI.actor.cpp             |  4 +-
 fdbclient/NativeAPI.actor.cpp                 | 10 ++--
 fdbclient/RYWIterator.cpp                     | 12 ++---
 fdbclient/RYWIterator.h                       | 12 ++---
 fdbclient/ReadYourWrites.actor.cpp            | 42 +++++++++-------
 fdbclient/WriteMap.h                          |  6 +--
 fdbclient/vexillographer/fdb.options          |  7 +--
 fdbserver/MasterProxyServer.actor.cpp         |  8 ++--
 .../workloads/FuzzApiCorrectness.actor.cpp    | 21 ++++----
 fdbserver/workloads/Unreadable.actor.cpp      | 15 ++----
 fdbserver/workloads/VersionStamp.actor.cpp    | 22 ++++-----
 fdbserver/workloads/WriteDuringRead.actor.cpp |  8 ++--
 flow/Arena.h                                  | 19 ++++++++
 15 files changed, 109 insertions(+), 133 deletions(-)

diff --git a/fdbclient/Atomic.h b/fdbclient/Atomic.h
index 70143a78e44..816aaf7bc3a 100644
--- a/fdbclient/Atomic.h
+++ b/fdbclient/Atomic.h
@@ -227,14 +227,14 @@ static KeyRangeRef getVersionstampKeyRange(Arena& arena, const KeyRef &key, cons
 	KeyRef begin(arena, key);
 	KeyRef end(arena, key);
 
-	if (begin.size() < 2)
+	if (begin.size() < 4)
 		throw client_invalid_operation();
 
-	int16_t pos;
-	memcpy(&pos, begin.end() - sizeof(int16_t), sizeof(int16_t));
-	pos = littleEndian16(pos);
-	begin = begin.substr(0, begin.size() - 2);
-	end = end.substr(0, end.size() - 1);
+	int32_t pos;
+	memcpy(&pos, begin.end() - sizeof(int32_t), sizeof(int32_t));
+	pos = littleEndian32(pos);
+	begin = begin.substr(0, begin.size() - 4);
+	end = end.substr(0, end.size() - 3);
 	mutateString(end)[end.size()-1] = 0;
 
 	if (pos < 0 || pos + 10 > begin.size())
@@ -255,39 +255,15 @@ static void placeVersionstamp( uint8_t* destination, Version version, uint16_t t
 	memcpy( destination + sizeof(version), &transactionNumber, sizeof(transactionNumber) );
 }
 
-static void transformSetVersionstampedKey( MutationRef& mutation, Version version, uint16_t transactionNumber ) {
-	// This transforms a SetVersionstampedKey mutation into a SetValue mutation.  
-	// It is the responsibility of the caller to also add a write conflict range for the new mutation's key.
-	if (mutation.param1.size() >= 2) {
-		int16_t pos;
-		memcpy(&pos, mutation.param1.end() - sizeof(int16_t), sizeof(int16_t));
-		pos = littleEndian16(pos);
-		mutation.param1 = mutation.param1.substr(0, mutation.param1.size() - 2);
-
-		if (pos >= 0 && pos + 10 <= mutation.param1.size()) {
-			placeVersionstamp( mutateString(mutation.param1) + pos, version, transactionNumber );
-		}
-	}
-
-	mutation.type = MutationRef::SetValue;
-}
-
-static void transformSetVersionstampedValue( MutationRef& mutation, Version version, uint16_t transactionNumber ) {
-	if (mutation.param2.size() >= 10)
-		placeVersionstamp( mutateString(mutation.param2), version, transactionNumber );
-
-	mutation.type = MutationRef::SetValue;
-}
-
-static void transformSetVersionstampedValuePos( MutationRef& mutation, Version version, uint16_t transactionNumber ) {
-	if (mutation.param2.size() >= 4) {
+static void transformVersionstampMutation( MutationRef& mutation, StringRef MutationRef::* param, Version version, uint16_t transactionNumber ) {
+	if ((mutation.*param).size() >= 4) {
 		int32_t pos;
-		memcpy(&pos, mutation.param2.end() - sizeof(int32_t), sizeof(int32_t));
+		memcpy(&pos, (mutation.*param).end() - sizeof(int32_t), sizeof(int32_t));
 		pos = littleEndian32(pos);
-		mutation.param2 = mutation.param2.substr(0, mutation.param2.size() - 4);
+		mutation.*param = (mutation.*param).substr(0, (mutation.*param).size() - 4);
 
-		if (pos >= 0 && pos + 10 <= mutation.param2.size()) {
-			placeVersionstamp( mutateString(mutation.param2) + pos, version, transactionNumber );
+		if (pos >= 0 && pos + 10 <= (mutation.*param).size()) {
+			placeVersionstamp( mutateString(mutation.*param) + pos, version, transactionNumber );
 		}
 	}
 
diff --git a/fdbclient/CommitTransaction.h b/fdbclient/CommitTransaction.h
index 911869bf252..8064849df19 100644
--- a/fdbclient/CommitTransaction.h
+++ b/fdbclient/CommitTransaction.h
@@ -24,11 +24,11 @@
 
 #include "FDBTypes.h"
 
-static const char * typeString[] = { "SetValue", "ClearRange", "AddValue", "DebugKeyRange", "DebugKey", "NoOp", "And", "Or", "Xor", "AppendIfFits", "AvailableForReuse", "Reserved_For_LogProtocolMessage", "Max", "Min", "SetVersionstampedKey", "SetVersionstampedValue", "ByteMin", "ByteMax", "MinV2", "AndV2", "SetVersionstampedValuePos" };
+static const char * typeString[] = { "SetValue", "ClearRange", "AddValue", "DebugKeyRange", "DebugKey", "NoOp", "And", "Or", "Xor", "AppendIfFits", "AvailableForReuse", "Reserved_For_LogProtocolMessage", "Max", "Min", "SetVersionstampedKey", "SetVersionstampedValue", "ByteMin", "ByteMax", "MinV2", "AndV2" };
 
 struct MutationRef { 
 	static const int OVERHEAD_BYTES = 12; //12 is the size of Header in MutationList entries
-	enum Type : uint8_t { SetValue=0, ClearRange, AddValue, DebugKeyRange, DebugKey, NoOp, And, Or, Xor, AppendIfFits, AvailableForReuse, Reserved_For_LogProtocolMessage /* See fdbserver/LogProtocolMessage.h */, Max, Min, SetVersionstampedKey, SetVersionstampedValue, ByteMin, ByteMax, MinV2, AndV2, SetVersionstampedValuePos, MAX_ATOMIC_OP };
+	enum Type : uint8_t { SetValue=0, ClearRange, AddValue, DebugKeyRange, DebugKey, NoOp, And, Or, Xor, AppendIfFits, AvailableForReuse, Reserved_For_LogProtocolMessage /* See fdbserver/LogProtocolMessage.h */, Max, Min, SetVersionstampedKey, SetVersionstampedValue, ByteMin, ByteMax, MinV2, AndV2, MAX_ATOMIC_OP };
 	// This is stored this way for serialization purposes.
 	uint8_t type;
 	StringRef param1, param2;
@@ -55,9 +55,9 @@ struct MutationRef {
 
 	// These masks define which mutation types have particular properties (they are used to implement isSingleKeyMutation() etc)
 	enum { 
-		ATOMIC_MASK = (1 << AddValue) | (1 << And) | (1 << Or) | (1 << Xor) | (1 << AppendIfFits) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << ByteMin) | (1 << ByteMax) | (1 << MinV2) | (1 << AndV2) | (1 << SetVersionstampedValuePos),
+		ATOMIC_MASK = (1 << AddValue) | (1 << And) | (1 << Or) | (1 << Xor) | (1 << AppendIfFits) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << ByteMin) | (1 << ByteMax) | (1 << MinV2) | (1 << AndV2),
 		SINGLE_KEY_MASK = ATOMIC_MASK | (1<<SetValue),
-		NON_ASSOCIATIVE_MASK = (1 << AddValue) | (1 << Or) | (1 << Xor) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << MinV2) | (1 << SetVersionstampedValuePos)
+		NON_ASSOCIATIVE_MASK = (1 << AddValue) | (1 << Or) | (1 << Xor) | (1 << Max) | (1 << Min) | (1 << SetVersionstampedKey) | (1 << SetVersionstampedValue) | (1 << MinV2)
 	};
 };
 
diff --git a/fdbclient/ManagementAPI.actor.cpp b/fdbclient/ManagementAPI.actor.cpp
index 75347245004..faba72a6973 100644
--- a/fdbclient/ManagementAPI.actor.cpp
+++ b/fdbclient/ManagementAPI.actor.cpp
@@ -1155,7 +1155,7 @@ ACTOR Future<Void> lockDatabase( Transaction* tr, UID id ) {
 		}
 	}
 
-	tr->atomicOp(databaseLockedKey, BinaryWriter::toValue(id, Unversioned()).withPrefix(LiteralStringRef("0123456789")), MutationRef::SetVersionstampedValue);
+	tr->atomicOp(databaseLockedKey, BinaryWriter::toValue(id, Unversioned()).withPrefix(LiteralStringRef("0123456789")).withSuffix(LiteralStringRef("\x00\x00\x00\x00")), MutationRef::SetVersionstampedValue);
 	tr->addWriteConflictRange(normalKeys);
 	return Void();
 }
@@ -1174,7 +1174,7 @@ ACTOR Future<Void> lockDatabase( Reference<ReadYourWritesTransaction> tr, UID id
 		}
 	}
 
-	tr->atomicOp(databaseLockedKey, BinaryWriter::toValue(id, Unversioned()).withPrefix(LiteralStringRef("0123456789")), MutationRef::SetVersionstampedValue);
+	tr->atomicOp(databaseLockedKey, BinaryWriter::toValue(id, Unversioned()).withPrefix(LiteralStringRef("0123456789")).withSuffix(LiteralStringRef("\x00\x00\x00\x00")), MutationRef::SetVersionstampedValue);
 	tr->addWriteConflictRange(normalKeys);
 	return Void();
 }
diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index 05e1915cf86..584fe1c5cb6 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -285,7 +285,7 @@ ACTOR static Future<Void> transactionInfoCommitActor(Transaction *tr, std::vecto
 			int64_t numCommitBytes = 0;
 			for (auto &chunk : *chunks) {
 				tr->atomicOp(chunk.key, chunk.value, MutationRef::SetVersionstampedKey);
-				numCommitBytes += chunk.key.size() + chunk.value.size() - 2; // subtract last 2 bytes of key that denotes verstion stamp index 
+				numCommitBytes += chunk.key.size() + chunk.value.size() - 4; // subtract number of bytes of key that denotes verstion stamp index
 			}
 			tr->atomicOp(clientLatencyAtomicCtr, StringRef((uint8_t*)&numCommitBytes, 8), MutationRef::AddValue);
 			Void _ = wait(tr->commit());
@@ -369,7 +369,7 @@ ACTOR static Future<Void> clientStatusUpdateActor(DatabaseContext *cx) {
 					TrInfoChunk chunk;
 					BinaryWriter chunkBW(Unversioned());
 					chunkBW << bigEndian32(i+1) << bigEndian32(num_chunks);
-					chunk.key = KeyRef(clientLatencyName + std::string(10, '\x00') + "/" + random_id + "/" + chunkBW.toStringRef().toString() + "/" + std::string(2, '\x00'));
+					chunk.key = KeyRef(clientLatencyName + std::string(10, '\x00') + "/" + random_id + "/" + chunkBW.toStringRef().toString() + "/" + std::string(4, '\x00'));
 					int16_t pos = littleEndian16(clientLatencyName.size());
 					memcpy(mutateString(chunk.key) + chunk.key.size() - sizeof(int16_t), &pos, sizeof(int16_t));
 					if (i == num_chunks - 1) {
@@ -2060,10 +2060,12 @@ void Transaction::atomicOp(const KeyRef& key, const ValueRef& operand, MutationR
 		else if (operationType == MutationRef::And)
 			operationType = MutationRef::AndV2;
 	}
+
 	auto &req = tr;
 	auto &t = req.transaction;
-	auto r = singleKeyRange( key, req.arena );
-	auto v = ValueRef( req.arena, operand );
+    auto r = singleKeyRange( key, req.arena );
+    auto v = ValueRef( req.arena, operand );
+
 	t.mutations.push_back( req.arena, MutationRef( operationType, r.begin, v ) );
 
 	if( addConflictRange )
diff --git a/fdbclient/RYWIterator.cpp b/fdbclient/RYWIterator.cpp
index b42cbdcea87..9b8085608d7 100644
--- a/fdbclient/RYWIterator.cpp
+++ b/fdbclient/RYWIterator.cpp
@@ -386,7 +386,7 @@ TEST_CASE("fdbclient/WriteMap/setVersionstampedKey") {
 	ASSERT(writes.empty());
 	ASSERT(getWriteMapCount(&writes) == 1);
 
-	writes.mutate(LiteralStringRef("stamp:XXXXXXXX\x06\x00"), MutationRef::SetVersionstampedKey, LiteralStringRef("1"), true);
+	writes.mutate(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00\x00"), MutationRef::SetVersionstampedKey, LiteralStringRef("1"), true);
 	ASSERT(!writes.empty());
 	ASSERT(getWriteMapCount(&writes) == 3);
 
@@ -398,7 +398,7 @@ TEST_CASE("fdbclient/WriteMap/setVersionstampedKey") {
 
 	ASSERT(it.beginKey() < allKeys.end);
 	ASSERT(it.beginKey().cmp(LiteralStringRef("")) == 0);
-	ASSERT(it.endKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00")) == 0);
+	ASSERT(it.endKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00\x00")) == 0);
 	ASSERT(!it.is_cleared_range());
 	ASSERT(!it.is_conflict_range());
 	ASSERT(!it.is_operation());
@@ -407,8 +407,8 @@ TEST_CASE("fdbclient/WriteMap/setVersionstampedKey") {
 	++it;
 
 	ASSERT(it.beginKey() < allKeys.end);
-	ASSERT(it.beginKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00")) == 0);
-	ASSERT(it.endKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00")) == 0);
+	ASSERT(it.beginKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00\x00")) == 0);
+	ASSERT(it.endKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00\x00\x00")) == 0);
 	ASSERT(!it.is_cleared_range());
 	ASSERT(it.is_conflict_range());
 	ASSERT(it.is_operation());
@@ -418,7 +418,7 @@ TEST_CASE("fdbclient/WriteMap/setVersionstampedKey") {
 	++it;
 
 	ASSERT(it.beginKey() < allKeys.end);
-	ASSERT(it.beginKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00")) == 0);
+	ASSERT(it.beginKey().cmp(LiteralStringRef("stamp:XXXXXXXX\x06\x00\x00\x00\x00")) == 0);
 	ASSERT(it.endKey().cmp(LiteralStringRef("stamp:ZZZZZZZZZZ")) == 0);
 	ASSERT(!it.is_cleared_range());
 	ASSERT(!it.is_conflict_range());
@@ -459,7 +459,7 @@ TEST_CASE("fdbclient/WriteMap/setVersionstampedValue") {
 	ASSERT(writes.empty());
 	ASSERT(getWriteMapCount(&writes) == 1);
 
-	writes.mutate(LiteralStringRef("stamp"), MutationRef::SetVersionstampedValue, LiteralStringRef("XXXXXXXX\x00\x00"), true);
+	writes.mutate(LiteralStringRef("stamp"), MutationRef::SetVersionstampedValue, LiteralStringRef("XXXXXXXX\x00\x00\x00\x00\x00\x00"), true);
 	ASSERT(!writes.empty());
 	ASSERT(getWriteMapCount(&writes) == 3);
 
diff --git a/fdbclient/RYWIterator.h b/fdbclient/RYWIterator.h
index 5bff2f63a8d..0fe0cdd3d20 100644
--- a/fdbclient/RYWIterator.h
+++ b/fdbclient/RYWIterator.h
@@ -80,12 +80,6 @@ class RandomTestImpl {
 	}
 
 	static ValueRef getRandomVersionstampValue(Arena& arena) {
-		int len = g_random->randomInt(10, 98);
-		std::string value = std::string(len, 'x');
-		return ValueRef(arena, value);
-	}
-
-	static ValueRef getRandomVersionstampValuePos(Arena& arena) {
 		int len = g_random->randomInt(10, 98);
 		std::string value = std::string(len, 'x');
 		int32_t pos = g_random->randomInt(0, len - 9);
@@ -104,15 +98,15 @@ class RandomTestImpl {
 			key += '\x00';
 		if (idx % 3 >= 2)
 			key += '\x00';
-		int16_t pos = key.size() - g_random->randomInt(0, 3);
+		int32_t pos = key.size() - g_random->randomInt(0, 3);
 		if (g_random->random01() < 0.01) {
 			pos = 0;
 		}
 		key = key.substr(0, pos);
 		key += "XXXXXXXXYY";
 		key += std::string(g_random->randomInt(0, 3), 'z');
-		pos = littleEndian16(pos);
-		key += std::string((const char*)&pos, sizeof(int16_t));
+		pos = littleEndian32(pos);
+		key += std::string((const char*)&pos, sizeof(int32_t));
 		return ValueRef(arena, key);
 	}
 
diff --git a/fdbclient/ReadYourWrites.actor.cpp b/fdbclient/ReadYourWrites.actor.cpp
index b143b52c296..f40a093124d 100644
--- a/fdbclient/ReadYourWrites.actor.cpp
+++ b/fdbclient/ReadYourWrites.actor.cpp
@@ -940,8 +940,8 @@ class RYWImpl {
 						std::swap(itCopy->value[i--], itCopy->value.back());
 					itCopy->value.pop_back();
 				} else if( !valueKnown || 
-					       (itCopy->value[i]->setPresent && (itCopy->value[i]->setValue.present() != val.present() || (val.present() && itCopy->value[i]->setValue.get() != val.get()))) ||
-					       (itCopy->value[i]->valuePresent && (itCopy->value[i]->value.present() != val.present() || (val.present() && itCopy->value[i]->value.get() != val.get()))) ) {
+						   (itCopy->value[i]->setPresent && (itCopy->value[i]->setValue.present() != val.present() || (val.present() && itCopy->value[i]->setValue.get() != val.get()))) ||
+						   (itCopy->value[i]->valuePresent && (itCopy->value[i]->value.present() != val.present() || (val.present() && itCopy->value[i]->value.get() != val.get()))) ) {
 					itCopy->value[i]->onChangeTrigger.send(Void());
 					if( i < itCopy->value.size() - 1 )
 						std::swap(itCopy->value[i--], itCopy->value.back());
@@ -1423,7 +1423,6 @@ void ReadYourWritesTransaction::writeRangeToNativeTransaction( KeyRangeRef const
 					case MutationRef::Min:
 					case MutationRef::SetVersionstampedKey:
 					case MutationRef::SetVersionstampedValue:
-					case MutationRef::SetVersionstampedValuePos:
 					case MutationRef::ByteMin:
 					case MutationRef::ByteMax:
 					case MutationRef::MinV2:
@@ -1488,6 +1487,26 @@ void ReadYourWritesTransaction::atomicOp( const KeyRef& key, const ValueRef& ope
 	if(operand.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)
 		throw value_too_large();
 
+	if (tr.apiVersionAtLeast(510)) {
+		if (operationType == MutationRef::Min)
+			operationType = MutationRef::MinV2;
+		else if (operationType == MutationRef::And)
+			operationType = MutationRef::AndV2;
+	}
+
+	KeyRef k;
+	if(!tr.apiVersionAtLeast(520) && operationType == MutationRef::SetVersionstampedKey) {
+		k = key.withSuffix( LiteralStringRef("\x00\x00"), arena );
+	} else {
+		k = KeyRef( arena, key );
+	}
+	ValueRef v;
+	if(!tr.apiVersionAtLeast(520) && operationType == MutationRef::SetVersionstampedValue) {
+		v = operand.withSuffix( LiteralStringRef("\x00\x00\x00\x00"), arena );
+	} else {
+		v = ValueRef( arena, operand );
+	}
+
 	if(operationType == MutationRef::SetVersionstampedKey) {
 		KeyRangeRef range = getVersionstampKeyRange(arena, key, getMaxReadKey()); // this does validation of the key and needs to be performed before the readYourWritesDisabled path
 		if(!options.readYourWritesDisabled) {
@@ -1496,10 +1515,7 @@ void ReadYourWritesTransaction::atomicOp( const KeyRef& key, const ValueRef& ope
 		}
 	}
 
-	if(operationType == MutationRef::SetVersionstampedValue && operand.size() < 10)
-		throw client_invalid_operation();
-
-	if(operationType == MutationRef::SetVersionstampedValuePos) {
+	if(operationType == MutationRef::SetVersionstampedValue) {
 		if(operand.size() < 4)
 			throw client_invalid_operation();
 		int32_t pos;
@@ -1508,21 +1524,11 @@ void ReadYourWritesTransaction::atomicOp( const KeyRef& key, const ValueRef& ope
 		if (pos < 0 || pos + 10 > operand.size() - 4)
 			throw client_invalid_operation();
 	}
-		
-	if (tr.apiVersionAtLeast(510)) {
-		if (operationType == MutationRef::Min)
-			operationType = MutationRef::MinV2;
-		else if (operationType == MutationRef::And)
-			operationType = MutationRef::AndV2;
-	}
 
 	if(options.readYourWritesDisabled) {
-		return tr.atomicOp(key, operand, (MutationRef::Type) operationType, addWriteConflict);
+		return tr.atomicOp(k, v, (MutationRef::Type) operationType, addWriteConflict);
 	}
 
-	KeyRef k = KeyRef( arena, key );
-	ValueRef v = ValueRef( arena, operand );
-
 	writes.mutate(k, (MutationRef::Type) operationType, v, addWriteConflict);
 	RYWImpl::triggerWatches(this, key, Optional<ValueRef>(), false);
 }
diff --git a/fdbclient/WriteMap.h b/fdbclient/WriteMap.h
index bb930c6aad9..d02ce009e07 100644
--- a/fdbclient/WriteMap.h
+++ b/fdbclient/WriteMap.h
@@ -65,7 +65,7 @@ class OperationStack {
 		bool isDependent() const {
 			if( !size() )
 				return false;
-			return singletonOperation.type != MutationRef::SetValue && singletonOperation.type != MutationRef::ClearRange && singletonOperation.type != MutationRef::SetVersionstampedValue && singletonOperation.type != MutationRef::SetVersionstampedValuePos && singletonOperation.type != MutationRef::SetVersionstampedKey;
+			return singletonOperation.type != MutationRef::SetValue && singletonOperation.type != MutationRef::ClearRange && singletonOperation.type != MutationRef::SetVersionstampedValue && singletonOperation.type != MutationRef::SetVersionstampedKey;
 		}
 		const RYWMutation& top() const { return hasVector() ? optionalOperations.get().back() : singletonOperation; }
 		RYWMutation& operator[] (int n) { return (n==0) ? singletonOperation : optionalOperations.get()[n-1]; }
@@ -142,8 +142,8 @@ class WriteMap {
 		bool following_conflict = it.entry().following_keys_conflict;
 		bool is_conflict = addConflict || it.is_conflict_range();
 		bool following_unreadable = it.entry().following_keys_unreadable;
-		bool is_unreadable = it.is_unreadable() || operation == MutationRef::SetVersionstampedValue || operation == MutationRef::SetVersionstampedValuePos || operation == MutationRef::SetVersionstampedKey;
-		bool is_dependent = operation != MutationRef::SetValue && operation != MutationRef::SetVersionstampedValue && operation!= MutationRef::SetVersionstampedValuePos && operation != MutationRef::SetVersionstampedKey;
+		bool is_unreadable = it.is_unreadable() || operation == MutationRef::SetVersionstampedValue ||  operation == MutationRef::SetVersionstampedKey;
+		bool is_dependent = operation != MutationRef::SetValue && operation != MutationRef::SetVersionstampedValue && operation != MutationRef::SetVersionstampedKey;
 
 		if (it.entry().key != key) {
 			if( it.is_cleared_range() && is_dependent ) {
diff --git a/fdbclient/vexillographer/fdb.options b/fdbclient/vexillographer/fdb.options
index 31ccf221cf8..7486b317741 100644
--- a/fdbclient/vexillographer/fdb.options
+++ b/fdbclient/vexillographer/fdb.options
@@ -230,19 +230,16 @@ description is not currently required but encouraged.
             description="Performs a little-endian comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored in the database. If the existing value in the database is shorter than ``param``, it is first extended to the length of ``param`` with zero bytes.  If ``param`` is shorter than the existing value in the database, the existing value is truncated to match the length of ``param``. The smaller of the two values is then stored in the database."/>
     <Option name="set_versionstamped_key" code="14"
             paramType="Bytes" paramDescription="value to which to set the transformed key"
-            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final two bytes from the key and reading those as a little-Endian 16-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0, and note that this strips the final two bytes fromt the end of the key, in contrast to versionstamp value operations, which either replace the first 10 bytes or strip the last four bytes, depending on the variant used. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamps are compatible with the Tuple layer only in the Java and Python bindings. They are also not currently compatible with the Subspace and Directory layer except in those languages and only in instances where they have already been set." />
+            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. They are also not currently compatible with the Subspace and Directory layer except in those languages and only in instances where they have already been set. Also, note that prior to API version 520, the offset was computed from only the final two bytes rather than the final four bytes." />
     <Option name="set_versionstamped_value" code="15"
             paramType="Bytes" paramDescription="value to versionstamp and set"
-            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by replacing the first 10 bytes of the value with the versionstamp of the transaction used. Note that this does not let the user insert a versionstamp at an arbitrary place in the value, in contrast to versionstamp key operations. This can be done using the other versionstamp value variant. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are not compatible with the Tuple layer." />
+            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps values are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the versionstamp was always placed at the beginning of the parameter rather than computing an offset." />
     <Option name="byte_min" code="16"
             paramType="Bytes" paramDescription="value to check against database value"
             description="Performs lexicographic comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored. Otherwise the smaller of the two values is then stored in the database."/>
     <Option name="byte_max" code="17"
             paramType="Bytes" paramDescription="value to check against database value"
             description="Performs lexicographic comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored. Otherwise the larger of the two values is then stored in the database."/>
-    <Option name="set_versionstamped_value_pos" code="20"
-            paramType="Bytes" paramDescription="value to versionstamp and set"
-            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0, and note that this strips the final four bytes from the end of parameter, in contrast to versionstamp key operations, which only strip the two bytes. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are compatible with the Tuple layer only in the Java and Python bindings." />
   </Scope>
 
   <Scope name="ConflictRangeType">
diff --git a/fdbserver/MasterProxyServer.actor.cpp b/fdbserver/MasterProxyServer.actor.cpp
index c8787c5a45f..a3f44575536 100644
--- a/fdbserver/MasterProxyServer.actor.cpp
+++ b/fdbserver/MasterProxyServer.actor.cpp
@@ -244,12 +244,10 @@ struct ResolutionRequestBuilder {
 		bool isTXNStateTransaction = false;
 		for (auto & m : trIn.mutations) {
 			if (m.type == MutationRef::SetVersionstampedKey) {
-				transformSetVersionstampedKey( m, requests[0].version, transactionNumberInBatch );
+                transformVersionstampMutation( m, &MutationRef::param1, requests[0].version, transactionNumberInBatch );
 				trIn.write_conflict_ranges.push_back( requests[0].arena, singleKeyRange( m.param1, requests[0].arena ) );
-			} else if (m.type == MutationRef::SetVersionstampedValue ) {
-				transformSetVersionstampedValue( m, requests[0].version, transactionNumberInBatch );
-			} else if (m.type == MutationRef::SetVersionstampedValuePos ) {
-				transformSetVersionstampedValuePos( m, requests[0].version, transactionNumberInBatch );
+			} else if (m.type == MutationRef::SetVersionstampedValue) {
+                transformVersionstampMutation( m, &MutationRef::param2, requests[0].version, transactionNumberInBatch );
 			}
 			if (isMetadataMutation(m)) {
 				isTXNStateTransaction = true;
diff --git a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
index 61dce7ffeff..9472be5cc6f 100644
--- a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
+++ b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
@@ -821,8 +821,7 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 		Key key;
 		Value value;
 		uint8_t op;
-		int16_t pos16;
-		int32_t pos32;
+		int32_t pos;
 
 		TestAtomicOp(unsigned int id, FuzzApiCorrectnessWorkload *workload) : BaseTestCallback(id, workload, "TestAtomicOp") {
 			key = makeKey();
@@ -854,13 +853,12 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 				op = g_random->randomInt(minval, maxval+1);
 			}
 
-			pos16 = -1;
-			if(op == MutationRef::SetVersionstampedKey && key.size() >= 2) {
-				pos16 = littleEndian16(*(int16_t*)&key.end()[-2]);
+			pos = -1;
+			if(op == MutationRef::SetVersionstampedKey && key.size() >= 4) {
+				pos = littleEndian32(*(int32_t*)&key.end()[-4]);
 			}
-			pos32 = -1;
-			if(op == MutationRef::SetVersionstampedValuePos && value.size() >= 4) {
-				pos32 = littleEndian32(*(int32_t*)&value.end()[-4]);
+			if(op == MutationRef::SetVersionstampedValue && value.size() >= 4) {
+				pos = littleEndian32(*(int32_t*)&value.end()[-4]);
 			}
 
 			contract = {
@@ -871,9 +869,8 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 				std::make_pair( error_code_key_outside_legal_range, ExceptionContract::requiredIf(
 							(key >= (workload->useSystemKeys ? systemKeys.end : normalKeys.end))) ),
 				std::make_pair( error_code_client_invalid_operation, ExceptionContract::requiredIf(
-							(op == MutationRef::SetVersionstampedValue && value.size() < 10) ||
-							(op == MutationRef::SetVersionstampedKey && (pos16 < 0 || pos16 + 10 > key.size() - 2)) ||
-							(op == MutationRef::SetVersionstampedValuePos && (pos32 < 0 || pos32 + 10 > value.size() - 4))) )
+							(op == MutationRef::SetVersionstampedKey && (pos < 0 || pos + 10 > key.size() - 4)) ||
+							(op == MutationRef::SetVersionstampedValue && (pos < 0 || pos + 10 > value.size() - 4))) )
 			};
 		}
 
@@ -883,7 +880,7 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 
 		void augmentTrace(TraceEvent &e) const {
 			base_type::augmentTrace(e);
-			e.detail("key", printable(key)).detail("value", printable(value)).detail("op", op).detail("pos16", pos16).detail("pos32", pos32);
+			e.detail("key", printable(key)).detail("value", printable(value)).detail("op", op).detail("pos", pos);
 		}
 	};
 
diff --git a/fdbserver/workloads/Unreadable.actor.cpp b/fdbserver/workloads/Unreadable.actor.cpp
index 3e6653c6ef9..b9307b3140f 100644
--- a/fdbserver/workloads/Unreadable.actor.cpp
+++ b/fdbserver/workloads/Unreadable.actor.cpp
@@ -308,7 +308,7 @@ struct UnreadableWorkload : TestWorkload {
 			setMap[normalKeys.end] = ValueRef();
 
 			for (; opCount < 500; opCount++) {
-				int r = g_random->randomInt(0, 20);
+				int r = g_random->randomInt(0, 19);
 				if (r <= 10) {
 					key = RandomTestImpl::getRandomKey(arena);
 					value = RandomTestImpl::getRandomValue(arena);
@@ -341,13 +341,6 @@ struct UnreadableWorkload : TestWorkload {
 					//TraceEvent("RYWT_setVersionstampValue").detail("key", printable(key));
 				}
 				else if (r == 15) {
-					key = RandomTestImpl::getRandomKey(arena);
-					value = RandomTestImpl::getRandomVersionstampValuePos(arena);
-					tr.atomicOp(key, value, MutationRef::SetVersionstampedValuePos);
-					unreadableMap.insert(key, true);
-					//TraceEvent("RYWT_setVersionstampValuePos").detail("key", printable(key));
-				}
-				else if (r == 16) {
 					key = RandomTestImpl::getRandomVersionstampKey(arena);
 					value = RandomTestImpl::getRandomValue(arena);
 					tr.atomicOp(key, value, MutationRef::SetVersionstampedKey);
@@ -355,7 +348,7 @@ struct UnreadableWorkload : TestWorkload {
 					unreadableMap.insert(range, true);
 					//TraceEvent("RYWT_setVersionstampKey").detail("range", printable(range));
 				}
-				else if (r == 17) {
+				else if (r == 16) {
 					range = RandomTestImpl::getRandomRange(arena);
 					snapshot = g_random->random01() < 0.05;
 					reverse = g_random->random01() < 0.5;
@@ -385,7 +378,7 @@ struct UnreadableWorkload : TestWorkload {
 						setMap[normalKeys.end] = ValueRef();
 					}
 				}
-				else if (r == 18) {
+				else if (r == 17) {
 					begin = RandomTestImpl::getRandomKeySelector(arena);
 					end = RandomTestImpl::getRandomKeySelector(arena);
 					limit = g_random->randomInt(1, 100);   // maximum number of results to return from the db
@@ -432,7 +425,7 @@ struct UnreadableWorkload : TestWorkload {
 						setMap[normalKeys.end] = ValueRef();
 					}		
 				}
-				else if (r == 19) {
+				else if (r == 18) {
 					key = RandomTestImpl::getRandomKey(arena);
 					snapshot = g_random->random01() < 0.05;
 
diff --git a/fdbserver/workloads/VersionStamp.actor.cpp b/fdbserver/workloads/VersionStamp.actor.cpp
index a59a214f57d..06565e391b0 100644
--- a/fdbserver/workloads/VersionStamp.actor.cpp
+++ b/fdbserver/workloads/VersionStamp.actor.cpp
@@ -76,15 +76,17 @@ struct VersionStampWorkload : TestWorkload {
 	}
 
 	Key versionStampKeyForIndex(uint64_t index) {
-		Key result = makeString(38);
+		Key result = makeString(40);
 		uint8_t* data = mutateString(result);
-		memset(&data[0], 'V', 38);
+		memset(&data[0], 'V', 40);
 
 		double d = double(index) / nodeCount;
 		emplaceIndex(data, 4, *(int64_t*)&d);
 
-		data[38 - 2] = 24 + vsKeyPrefix.size();
-		data[38 - 1] = 0;
+		data[40 - 4] = 24 + vsKeyPrefix.size();
+		data[40 - 3] = 0;
+		data[40 - 2] = 0;
+		data[40 - 1] = 0;
 		return result.withPrefix(vsKeyPrefix);
 	}
 
@@ -234,21 +236,13 @@ struct VersionStampWorkload : TestWorkload {
 			state Version committedVersion;
 
 			bool useVersionstampPos = (g_random->random01() < 0.5);
-			state MutationRef::Type valueMutation;
-			state Value versionStampValue;
-			if(useVersionstampPos) {
-				versionStampValue = LiteralStringRef("\x00\x00\x00\x00").withPrefix(value);
-				valueMutation = MutationRef::SetVersionstampedValuePos;
-			} else {
-				versionStampValue = value;
-				valueMutation = MutationRef::SetVersionstampedValue;
-			}
+			state Value versionStampValue = value.withSuffix(LiteralStringRef("\x00\x00\x00\x00"));
 
 			loop{
 				state bool error = false;
 				//TraceEvent("VST_commit_begin").detail("key", printable(key)).detail("vsKey", printable(versionStampKey)).detail("clear", printable(range));
 				try {
-					tr.atomicOp(key, versionStampValue, valueMutation);
+					tr.atomicOp(key, versionStampValue, MutationRef::SetVersionstampedValue);
 					tr.clear(range);
 					tr.atomicOp(versionStampKey, value, MutationRef::SetVersionstampedKey);
 					state Future<Standalone<StringRef>> fTrVs = tr.getVersionstamp();
diff --git a/fdbserver/workloads/WriteDuringRead.actor.cpp b/fdbserver/workloads/WriteDuringRead.actor.cpp
index 9dce38f085e..7d921320659 100644
--- a/fdbserver/workloads/WriteDuringRead.actor.cpp
+++ b/fdbserver/workloads/WriteDuringRead.actor.cpp
@@ -513,11 +513,11 @@ struct WriteDuringReadWorkload : TestWorkload {
 	}
 
 	Key versionStampKeyForIndex( int idx ) {
-		Key result = KeyRef( getKeyForIndex(idx).toString() + std::string(12,'\x00') );
-		int16_t pos = g_random->randomInt(0, result.size() - 11);
-		pos = littleEndian16(pos);
+		Key result = KeyRef( getKeyForIndex(idx).toString() + std::string(14,'\x00') );
+		int32_t pos = g_random->randomInt(0, result.size() - 13);
+		pos = littleEndian32(pos);
 		uint8_t* data = mutateString(result);
-		memcpy(data+result.size()-sizeof(int16_t), &pos, sizeof(int16_t));
+		memcpy(data+result.size()-sizeof(int32_t), &pos, sizeof(int32_t));
 		return result;
 	}
 
diff --git a/flow/Arena.h b/flow/Arena.h
index 651fd077497..ea4cd392434 100644
--- a/flow/Arena.h
+++ b/flow/Arena.h
@@ -429,18 +429,37 @@ class StringRef {
 		return StringRef(s,prefix.size() + size());
 	}
 
+	StringRef withSuffix( const StringRef& suffix, Arena& arena ) const {
+		uint8_t* s = new (arena) uint8_t[ suffix.size() + size() ];
+		memcpy(s, begin(), size());
+		memcpy(s+size(), suffix.begin(), suffix.size());
+		return StringRef(s,suffix.size() + size());
+	}
+
 	Standalone<StringRef> withPrefix( const StringRef& prefix ) const {
 		Standalone<StringRef> r;
 		((StringRef &)r) = withPrefix(prefix, r.arena());
 		return r;
 	}
 
+	Standalone<StringRef> withSuffix( const StringRef& suffix ) const {
+		Standalone<StringRef> r;
+		((StringRef &)r) = withSuffix(suffix, r.arena());
+		return r;
+	}
+
 	StringRef removePrefix( const StringRef& s ) const {
 		// pre: startsWith(s)
 		UNSTOPPABLE_ASSERT( s.size() <= size() );  //< In debug mode, we could check startsWith()
 		return substr( s.size() );
 	}
 
+	StringRef removeSuffix( const StringRef& s ) const {
+		// pre: endsWith(s)
+		UNSTOPPABLE_ASSERT( s.size() <= size() );  //< In debug mode, we could check endsWith()
+		return substr( 0, size() - s.size() );
+	}
+
 	std::string toString() const { return std::string( (const char*)data, length ); }
 	std::string printable() const {
 		std::string s;

From 8987d21df33d3e234649b9a00c0f2c5fb0ec55fd Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Mon, 26 Mar 2018 11:50:25 -0700
Subject: [PATCH 5/7] use new semantics when writing position of vs key in
 native api

---
 fdbclient/NativeAPI.actor.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index 584fe1c5cb6..75fe22f1431 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -370,8 +370,8 @@ ACTOR static Future<Void> clientStatusUpdateActor(DatabaseContext *cx) {
 					BinaryWriter chunkBW(Unversioned());
 					chunkBW << bigEndian32(i+1) << bigEndian32(num_chunks);
 					chunk.key = KeyRef(clientLatencyName + std::string(10, '\x00') + "/" + random_id + "/" + chunkBW.toStringRef().toString() + "/" + std::string(4, '\x00'));
-					int16_t pos = littleEndian16(clientLatencyName.size());
-					memcpy(mutateString(chunk.key) + chunk.key.size() - sizeof(int16_t), &pos, sizeof(int16_t));
+					int32_t pos = littleEndian32(clientLatencyName.size());
+					memcpy(mutateString(chunk.key) + chunk.key.size() - sizeof(int32_t), &pos, sizeof(int32_t));
 					if (i == num_chunks - 1) {
 						chunk.value = ValueRef(static_cast<uint8_t *>(bw.getData()) + (i * value_size_limit), bw.getLength() - (i * value_size_limit));
 					}

From 47c9e4f92312d26b77ed396e7e544fcfd677647c Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Wed, 11 Apr 2018 18:47:11 -0700
Subject: [PATCH 6/7] update bindings and bindingtester that uses versionstamps
 to use new protocol

issue #148
---
 bindings/bindingtester/tests/__init__.py      | 15 ++++
 bindings/bindingtester/tests/api.py           | 57 +++++++-------
 bindings/bindingtester/tests/scripted.py      | 19 ++++-
 bindings/flow/tester/Tester.actor.cpp         |  1 -
 bindings/go/src/fdb/generated.go              |  4 +-
 .../apple/foundationdb/subspace/Subspace.java | 35 +--------
 .../com/apple/foundationdb/tuple/Tuple.java   | 77 ++-----------------
 .../apple/foundationdb/tuple/TupleUtil.java   | 14 ++--
 .../foundationdb/test/AsyncStackTester.java   |  9 +--
 .../foundationdb/test/StackOperation.java     |  3 +-
 .../apple/foundationdb/test/StackTester.java  |  9 +--
 .../test/VersionstampSmokeTest.java           |  2 +-
 bindings/python/fdb/tuple.py                  | 24 ++----
 bindings/python/tests/tester.py               | 40 +---------
 fdbclient/vexillographer/fdb.options          |  4 +-
 fdbserver/MasterProxyServer.actor.cpp         |  4 +-
 16 files changed, 93 insertions(+), 224 deletions(-)

diff --git a/bindings/bindingtester/tests/__init__.py b/bindings/bindingtester/tests/__init__.py
index 20f45835e6d..89835affaed 100644
--- a/bindings/bindingtester/tests/__init__.py
+++ b/bindings/bindingtester/tests/__init__.py
@@ -20,6 +20,7 @@
 
 import math
 import re
+import struct
 
 import fdb
 
@@ -80,6 +81,20 @@ def get_expected_results(self):
     def validate(self, db, args):
         return []
 
+    def versionstamp_key(self, raw_bytes, version_pos):
+        if hasattr(self, 'api_version') and self.api_version < 520:
+            return raw_bytes + struct.pack('<H', version_pos)
+        else:
+            return raw_bytes + struct.pack('<L', version_pos)
+
+    def versionstamp_value(self, raw_bytes, version_pos=0):
+        if hasattr(self, 'api_version') and self.api_version < 520:
+            if version_pos != 0:
+                raise ValueError("unable to set non-zero version position before 520 in values")
+            return raw_bytes
+        else:
+            return raw_bytes + struct.pack('<L', version_pos)
+
     @classmethod
     def create_test(cls, name, subspace):
         target = 'bindingtester.tests.%s' % name
diff --git a/bindings/bindingtester/tests/api.py b/bindings/bindingtester/tests/api.py
index 32cfee63243..ccad9d39b31 100644
--- a/bindings/bindingtester/tests/api.py
+++ b/bindings/bindingtester/tests/api.py
@@ -57,6 +57,7 @@ def setup(self, args):
         self.generated_keys = []
         self.outstanding_ops = []
         self.random = test_util.RandomGenerator(args.max_int_bits, args.api_version, args.types)
+        self.api_version = args.api_version
 
     def add_stack_items(self, num):
         self.stack_size += num
@@ -151,7 +152,7 @@ def generate(self, args, thread_number):
         snapshot_versions = ['GET_READ_VERSION_SNAPSHOT']
         tuples = ['TUPLE_PACK', 'TUPLE_UNPACK', 'TUPLE_RANGE', 'TUPLE_SORT', 'SUB', 'ENCODE_FLOAT', 'ENCODE_DOUBLE', 'DECODE_DOUBLE', 'DECODE_FLOAT']
         if 'versionstamp' in args.types:
-            tuples += ['TUPLE_PACK_VERSIONSTAMPED_KEY', 'TUPLE_PACK_VERSIONSTAMPED_VALUE']
+            tuples.append('TUPLE_PACK_WITH_VERSIONSTAMP')
         resets = ['ON_ERROR', 'RESET', 'CANCEL']
         read_conflicts = ['READ_CONFLICT_RANGE', 'READ_CONFLICT_KEY']
         write_conflicts = ['WRITE_CONFLICT_RANGE', 'WRITE_CONFLICT_KEY', 'DISABLE_WRITE_CONFLICT']
@@ -362,13 +363,16 @@ def generate(self, args, thread_number):
                 rand_str2 = prefix + fdb.tuple.Versionstamp._UNSET_TR_VERSION + suffix
                 key3 = self.versionstamped_keys.pack() + rand_str2
                 index = len(self.versionstamped_keys.pack()) + len(prefix)
-                key3 += chr(index % 256) + chr(index / 256)
+                key3 = self.versionstamp_key(key3, index)
 
-                instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', key1, fdb.tuple.Versionstamp._UNSET_TR_VERSION + rand_str2)
+                instructions.push_args(u'SET_VERSIONSTAMPED_VALUE',
+                                       key1,
+                                       self.versionstamp_value(fdb.tuple.Versionstamp._UNSET_TR_VERSION + rand_str2))
                 instructions.append('ATOMIC_OP')
 
-                instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS', key2, rand_str2 + struct.pack('<L', len(prefix)))
-                instructions.append('ATOMIC_OP')
+                if args.api_version >= 520:
+                    instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', key2, self.versionstamp_value(rand_str2, len(prefix)))
+                    instructions.append('ATOMIC_OP')
 
                 instructions.push_args(u'SET_VERSIONSTAMPED_KEY', key3, rand_str1)
                 instructions.append('ATOMIC_OP')
@@ -439,9 +443,9 @@ def generate(self, args, thread_number):
                 else:
                     self.add_strings(2)
 
-            elif op == 'TUPLE_PACK_VERSIONSTAMPED_KEY' or op == 'TUPLE_PACK_VERSIONSTAMPED_VALUE':
+            elif op == 'TUPLE_PACK_WITH_VERSIONSTAMP':
                 tup = (self.random.random_string(20),) + self.random.random_tuple(10, incomplete_versionstamps=True)
-                prefix = self.versionstamped_keys.pack() if op == 'TUPLE_PACK_VERSIONSTAMPED_KEY' else ''
+                prefix = self.versionstamped_keys.pack()
                 instructions.push_args(prefix, len(tup), *tup)
                 instructions.append(op)
                 self.add_strings(1)
@@ -455,30 +459,20 @@ def generate(self, args, thread_number):
                 if first_incomplete >= 0 and second_incomplete < 0:
                     rand_str = self.random.random_string(100)
 
-                    if op == 'TUPLE_PACK_VERSIONSTAMPED_KEY':
-                        instructions.push_args(rand_str)
-                        test_util.to_front(instructions, 1)
-                        instructions.push_args(u'SET_VERSIONSTAMPED_KEY')
-                        instructions.append('ATOMIC_OP')
+                    instructions.push_args(rand_str)
+                    test_util.to_front(instructions, 1)
+                    instructions.push_args(u'SET_VERSIONSTAMPED_KEY')
+                    instructions.append('ATOMIC_OP')
 
+                    if self.api_version >= 520:
                         version_value_key_2 = self.versionstamped_values_2.pack((rand_str,))
-                        versionstamped_value = fdb.tuple.pack(tup) + struct.pack('<L', first_incomplete - len(prefix))
-                        instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS', version_value_key_2, versionstamped_value)
-                        instructions.append('ATOMIC_OP')
-
-                    else:
-                        instructions.push_args(self.versionstamped_values_2.pack((rand_str,)))
-                        instructions.push_args(u'SET_VERSIONSTAMPED_VALUE_POS')
-                        instructions.append('ATOMIC_OP')
-
-                        versionstamped_key = self.versionstamped_keys.pack() + versionstamp_param \
-                            + struct.pack('<H', first_incomplete + len(self.versionstamped_keys.pack()))
-                        instructions.push_args(u'SET_VERSIONSTAMPED_KEY', versionstamped_key, rand_str)
+                        versionstamped_value = self.versionstamp_value(fdb.tuple.pack(tup), first_incomplete - len(prefix))
+                        instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', version_value_key_2, versionstamped_value)
                         instructions.append('ATOMIC_OP')
 
                     version_value_key = self.versionstamped_values.pack((rand_str,))
                     instructions.push_args(u'SET_VERSIONSTAMPED_VALUE', version_value_key,
-                                           fdb.tuple.Versionstamp._UNSET_TR_VERSION + fdb.tuple.pack(tup))
+                                           self.versionstamp_value(fdb.tuple.Versionstamp._UNSET_TR_VERSION + fdb.tuple.pack(tup)))
                     instructions.append('ATOMIC_OP')
                     self.can_use_key_selectors = False
 
@@ -538,7 +532,7 @@ def generate(self, args, thread_number):
                 self.add_strings(1)
 
             else:
-                assert False
+                assert False, 'Unknown operation: ' + op
 
             if read_performed and op not in database_reads:
                 self.outstanding_ops.append((self.stack_size, len(instructions) - 1))
@@ -576,11 +570,12 @@ def check_versionstamps(self, tr, begin_key, limit):
                 util.get_logger().error('    %s != %s', repr(tr[versioned_key]), repr(random_id))
                 incorrect_versionstamps += 1
 
-            k2 = self.versionstamped_values_2.pack((random_id,))
-            if tr[k2] != versioned_value:
-                util.get_logger().error('  INCORRECT VERSIONSTAMP:')
-                util.get_logger().error('    %s != %s', repr(tr[k2]), repr(versioned_value))
-                incorrect_versionstamps += 1
+            if self.api_version >= 520:
+                k2 = self.versionstamped_values_2.pack((random_id,))
+                if tr[k2] != versioned_value:
+                    util.get_logger().error('  INCORRECT VERSIONSTAMP:')
+                    util.get_logger().error('    %s != %s', repr(tr[k2]), repr(versioned_value))
+                    incorrect_versionstamps += 1
 
         return (next_begin, incorrect_versionstamps)
 
diff --git a/bindings/bindingtester/tests/scripted.py b/bindings/bindingtester/tests/scripted.py
index dd768957b9f..a04c21f1805 100644
--- a/bindings/bindingtester/tests/scripted.py
+++ b/bindings/bindingtester/tests/scripted.py
@@ -54,6 +54,8 @@ def setup(self, args):
         if args.bisect:
             raise Exception('Scripted tests cannot be bisected')
 
+        self.api_version = args.api_version
+
     def generate(self, args, thread_number):
         self.results = []
 
@@ -272,12 +274,17 @@ def generate(self, args, thread_number):
 
         stampKey = 'stampedXXXXXXXXXXsuffix'
         stampKeyIndex = stampKey.find('XXXXXXXXXX')
-        stampKeyStr = chr(stampKeyIndex % 256) + chr(stampKeyIndex / 256)
-        main_thread.push_args(u'SET_VERSIONSTAMPED_KEY', stampKey + stampKeyStr, 'stampedBar')
+        main_thread.push_args(u'SET_VERSIONSTAMPED_KEY', self.versionstamp_key(stampKey, stampKeyIndex), 'stampedBar')
         main_thread.append('ATOMIC_OP')
-        main_thread.push_args(u'SET_VERSIONSTAMPED_VALUE', 'stampedValue', 'XXXXXXXXXX')
+        main_thread.push_args(u'SET_VERSIONSTAMPED_VALUE', 'stampedValue', self.versionstamp_value('XXXXXXXXXX'))
         main_thread.append('ATOMIC_OP')
 
+        if self.api_version >= 520:
+            stampValue = 'stampedXXXXXXXXXXsuffix'
+            stampValueIndex = stampValue.find('XXXXXXXXXX')
+            main_thread.push_args(u'SET_VERSIONSTAMPED_VALUE', 'stampedValue2', self.versionstamp_value(stampValue, stampValueIndex))
+            main_thread.append('ATOMIC_OP')
+
         main_thread.push_args('suffix')
         main_thread.append('GET_VERSIONSTAMP')
         test_util.blocking_commit(main_thread)
@@ -296,6 +303,12 @@ def generate(self, args, thread_number):
         main_thread.append('GET')
         self.add_result(main_thread, args, 'stampedBar')
 
+        if self.api_version >= 520:
+            main_thread.push_args('stampedValue2')
+            main_thread.append('GET')
+            main_thread.append('GET')
+            self.add_result(main_thread, args, 'stampedBar')
+
         main_thread.append('GET_VERSIONSTAMP')
         test_util.blocking_commit(main_thread)
         self.add_result(main_thread, args, 'RESULT_NOT_PRESENT')
diff --git a/bindings/flow/tester/Tester.actor.cpp b/bindings/flow/tester/Tester.actor.cpp
index 5c63065b0d9..7138c314c9f 100644
--- a/bindings/flow/tester/Tester.actor.cpp
+++ b/bindings/flow/tester/Tester.actor.cpp
@@ -1676,7 +1676,6 @@ void populateAtomicOpMap() {
 	optionInfo["MIN"] = FDBMutationType::FDB_MUTATION_TYPE_MIN;
 	optionInfo["SET_VERSIONSTAMPED_KEY"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_KEY;
 	optionInfo["SET_VERSIONSTAMPED_VALUE"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_VALUE;
-	optionInfo["SET_VERSIONSTAMPED_VALUE_POS"] = FDBMutationType::FDB_MUTATION_TYPE_SET_VERSIONSTAMPED_VALUE_POS;
 	optionInfo["BYTE_MIN"] = FDBMutationType::FDB_MUTATION_TYPE_BYTE_MIN;
 	optionInfo["BYTE_MAX"] = FDBMutationType::FDB_MUTATION_TYPE_BYTE_MAX;
 }
diff --git a/bindings/go/src/fdb/generated.go b/bindings/go/src/fdb/generated.go
index 19909214660..dd55074e265 100644
--- a/bindings/go/src/fdb/generated.go
+++ b/bindings/go/src/fdb/generated.go
@@ -445,12 +445,12 @@ func (t Transaction) Min(key KeyConvertible, param []byte) {
 	t.atomicOp(key.FDBKey(), param, 13)
 }
 
-// SetVersionstampedKey transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database. The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Note that this implies versionstamped keys may not be used with the Subspace and Directory layers except in those languages.
+// SetVersionstampedKey transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the offset was computed from only the final two bytes rather than the final four bytes.
 func (t Transaction) SetVersionstampedKey(key KeyConvertible, param []byte) {
 	t.atomicOp(key.FDBKey(), param, 14)
 }
 
-// SetVersionstampedValue transforms ``param`` using a versionstamp for the transaction. Sets ``key`` in the database to the transformed parameter. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database. The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time versionstamped values are not compatible with the Tuple layer.
+// SetVersionstampedValue transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from ``param`` and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the versionstamp was always placed at the beginning of the parameter rather than computing an offset.
 func (t Transaction) SetVersionstampedValue(key KeyConvertible, param []byte) {
 	t.atomicOp(key.FDBKey(), param, 15)
 }
diff --git a/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java b/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
index e962d60b8e2..26bc34177e7 100644
--- a/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
+++ b/bindings/java/src/main/com/apple/foundationdb/subspace/Subspace.java
@@ -199,23 +199,6 @@ public byte[] pack(Tuple tuple) {
 		return tuple.pack(rawPrefix);
 	}
 
-	/**
-	 * Deprecated. Use {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} instead. Because
-	 * the serialization formats are different for versionstamped keys and values, this method was
-	 * deprecated to encourage developers to choose appropriately between
-	 * {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} and
-	 * {@link #packVersionstampedValue(Tuple)} packVersionstampedValue()}.
-	 *
-	 * @param tuple the {@code Tuple} to be packed
-	 * @return the key encoding the specified tuple in this {@code Subspace}
-	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
-	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedKey(Tuple) packVersionstampedKey()}
-	 */
-	@Deprecated
-	public byte[] packWithVersionstamp(Tuple tuple) {
-		return packVersionstampedKey(tuple);
-	}
-
 	/**
 	 * Gets the key encoding the specified tuple in this {@code Subspace} for use with
 	 * {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_KEY MutationType.SET_VERSIONSTAMPED_KEY}.
@@ -230,22 +213,8 @@ public byte[] packWithVersionstamp(Tuple tuple) {
 	 * @return the key encoding the specified tuple in this {@code Subspace}
 	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
 	 */
-	public byte[] packVersionstampedKey(Tuple tuple) {
-		return tuple.packVersionstampedKey(rawPrefix);
-	}
-
-	/**
-	 * Gets the key encoding the specified tuple in this {@code Subspace} for use with
-	 * {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE MutationType.SET_VERSIONSTAMPED_VALUE}.
-	 * This works just like {@link #packVersionstampedKey(Tuple) packVersionstampedKey()} except that
-	 * the final serialization format is different.
-	 *
-	 * @param tuple the {@code Tuple} to be packed
-	 * @return the key encoding the specified tuple in this {@code Subspace}
-	 * @throws IllegalArgumentException if {@code tuple} does not contain exactly one incomplete {@link Versionstamp}
-	 */
-	public byte[] packVersionstampedValue(Tuple tuple) {
-		return tuple.packVersionstampedValue(rawPrefix);
+	public byte[] packWithVersionstamp(Tuple tuple) {
+		return tuple.packWithVersionstamp(rawPrefix);
 	}
 
 	/**
diff --git a/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java b/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
index 65c46078fdc..0886cc6fe48 100644
--- a/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
+++ b/bindings/java/src/main/com/apple/foundationdb/tuple/Tuple.java
@@ -302,50 +302,17 @@ public byte[] pack(byte[] prefix) {
 		return TupleUtil.pack(elements, prefix);
 	}
 
-	/**
-	 * Deprecated. Use {@link #packVersionstampedKey() packVersionstampedKey()} instead. Because
-	 *  versionstamped keys and versionstamped values are serialized differently, this method was deprecated
-	 *  to encourage developers to choose appropriately between
-	 *  {@link #packVersionstampedKey() packVersionstampedKey()} and
-	 *  {@link #packVersionstampedValue() packVersionstampedValue}.
-	 *
-	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
-	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
-	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedKey() packVersionstampedKey()}
-	 */
-	@Deprecated
-	public byte[] packWithVersionstamp() {
-		return packWithVersionstamp(null);
-	}
-
-	/**
-	 * Deprecated. Use {@link #packVersionstampedKey(byte[]) packVersionstampedKey()} instead. Because
-	 *  versionstamped keys and versionstamped values are serialized differently, this method was deprecated
-	 *  to encourage developers to choose appropriately between
-	 *  {@link #packVersionstampedKey(byte[]) packVersionstampedKey()} and
-	 *  {@link #packVersionstampedValue(byte[]) packVersionstampedValue}.
-	 *
-	 * @param prefix additional byte-array prefix to prepend to serialized bytes.
-	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
-	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
-	 * @deprecated Since 5.2.0, replaced with {@link #packVersionstampedValue(byte[]) packVersionstampedKey()}
-	 */
-	@Deprecated
-	public byte[] packWithVersionstamp(byte[] prefix) {
-		return packVersionstampedKey(prefix);
-	}
-
 	/**
 	 * Get an encoded representation of this {@code Tuple} for use with
 	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_KEY MutationType.SET_VERSIONSTAMPED_KEY}.
-	 *  This works the same as the {@link #packVersionstampedKey(byte[]) one-paramter version of this method},
+	 *  This works the same as the {@link #packWithVersionstamp(byte[]) one-paramter version of this method},
 	 *  but it does not add any prefix to the array.
 	 *
 	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
 	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
 	 */
-	public byte[] packVersionstampedKey() {
-		return packVersionstampedKey(null);
+	public byte[] packWithVersionstamp() {
+		return packWithVersionstamp(null);
 	}
 
 	/**
@@ -365,42 +332,8 @@ public byte[] packVersionstampedKey() {
 	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
 	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
 	 */
-	public byte[] packVersionstampedKey(byte[] prefix) {
-		return TupleUtil.packWithVersionstamp(elements, prefix, false);
-	}
-
-	/**
-	 * Get an encoded representation of this {@code Tuple} for use with
-	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE_POS MutationType.SET_VERSIONSTAMPED_VALUE_POS}.
-	 *  This works the same as the {@link #packVersionstampedValue(byte[]) one-paramter version of this method},
-	 *  but it does not add any prefix to the array.
-	 *
-	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
-	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
-	 */
-	public byte[] packVersionstampedValue() {
-		return packVersionstampedValue(null);
-	}
-
-	/**
-	 * Get an encoded representation of this {@code Tuple} for use with
-	 *  {@link com.apple.foundationdb.MutationType#SET_VERSIONSTAMPED_VALUE_POS MutationType.SET_VERSIONSTAMPED_VALUE_POS}.
-	 *  There must be exactly one incomplete {@link Versionstamp} instance within this
-	 *  {@code Tuple} or this will throw an {@link IllegalArgumentException}.
-	 *  Each element is encoded to {@code byte}s and concatenated, the prefix
-	 *  is then prepended to the array, and then the index of the serialized incomplete
-	 *  {@link Versionstamp} is appended as a little-endian integer. This can then be passed
-	 *  as the value to
-	 *  {@link com.apple.foundationdb.Transaction#mutate(com.apple.foundationdb.MutationType, byte[], byte[]) Transaction.mutate()}
-	 *  with the {@code SET_VERSIONSTAMPED_VALUE_POS} {@link com.apple.foundationdb.MutationType}, and the transaction's
-	 *  version will then be filled in at commit time.
-	 *
-	 * @param prefix additional byte-array prefix to prepend to serialized bytes.
-	 * @return a serialized representation of this {@code Tuple} for use with versionstamp ops.
-	 * @throws IllegalArgumentException if there is not exactly one incomplete {@link Versionstamp} included in this {@code Tuple}
-	 */
-	public byte[] packVersionstampedValue(byte[] prefix) {
-		return TupleUtil.packWithVersionstamp(elements, prefix, true);
+	public byte[] packWithVersionstamp(byte[] prefix) {
+		return TupleUtil.packWithVersionstamp(elements, prefix);
 	}
 
 	/**
diff --git a/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java b/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
index 3316044dd1d..14893daba3d 100644
--- a/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
+++ b/bindings/java/src/main/com/apple/foundationdb/tuple/TupleUtil.java
@@ -33,6 +33,8 @@
 import java.util.UUID;
 import java.util.stream.Stream;
 
+import com.apple.foundationdb.FDB;
+
 class TupleUtil {
 	private static final byte nil = 0x00;
 	private static final BigInteger[] size_limits;
@@ -569,7 +571,7 @@ static EncodeResult encodeAll(List<Object> items, byte[] prefix, List<byte[]> en
 	}
 
 	static byte[] pack(List<Object> items, byte[] prefix) {
-		List<byte[]> encoded = new ArrayList<byte[]>(2 * items.size() + (prefix == null ? 0 : 1));
+		List<byte[]> encoded = new ArrayList<>(2 * items.size() + (prefix == null ? 0 : 1));
 		EncodeResult result = encodeAll(items, prefix, encoded);
 		if(result.versionPos > 0) {
 			throw new IllegalArgumentException("Incomplete Versionstamp included in vanilla tuple pack");
@@ -578,8 +580,8 @@ static byte[] pack(List<Object> items, byte[] prefix) {
 		}
 	}
 
-	static byte[] packWithVersionstamp(List<Object> items, byte[] prefix, boolean forValue) {
-		List<byte[]> encoded = new ArrayList<byte[]>(2 * items.size() + (prefix == null ? 1 : 2));
+	static byte[] packWithVersionstamp(List<Object> items, byte[] prefix) {
+		List<byte[]> encoded = new ArrayList<>(2 * items.size() + (prefix == null ? 1 : 2));
 		EncodeResult result = encodeAll(items, prefix, encoded);
 		if(result.versionPos < 0) {
 			throw new IllegalArgumentException("No incomplete Versionstamp included in tuple pack with versionstamp");
@@ -587,10 +589,10 @@ static byte[] packWithVersionstamp(List<Object> items, byte[] prefix, boolean fo
 			if(result.versionPos > 0xffff) {
 				throw new IllegalArgumentException("Tuple has incomplete version at position " + result.versionPos + " which is greater than the maximum " + 0xffff);
 			}
-			if (forValue) {
-				encoded.add(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(result.versionPos).array());
-			} else {
+			if (FDB.instance().getAPIVersion() < 520) {
 				encoded.add(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort((short)result.versionPos).array());
+			} else {
+				encoded.add(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(result.versionPos).array());
 			}
 			return ByteArrayUtil.join(null, encoded);
 		}
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java b/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
index 990791c668e..a81df36a73a 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/AsyncStackTester.java
@@ -360,7 +360,7 @@ else if(op == StackOperation.TUPLE_PACK) {
 				}, FDB.DEFAULT_EXECUTOR);
 			}, FDB.DEFAULT_EXECUTOR);
 		}
-		else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_VALUE) {
+		else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
 			return inst.popParams(2).thenComposeAsync(params -> {
 				byte[] prefix = (byte[])params.get(0);
 				int tupleSize = StackUtils.getInt(params.get(1));
@@ -372,12 +372,7 @@ else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperati
 						return;
 					}
 					try {
-						byte[] coded;
-						if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY) {
-							coded = tuple.packVersionstampedKey(prefix);
-						} else {
-							coded = tuple.packVersionstampedValue(prefix);
-						}
+						byte[] coded = tuple.packWithVersionstamp(prefix);
 						inst.push("OK".getBytes());
 						inst.push(coded);
 					} catch(IllegalArgumentException e) {
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java b/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
index 894fa3d4f25..7fdc7b9ff5c 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/StackOperation.java
@@ -60,8 +60,7 @@ enum StackOperation {
 	SUB,
 	CONCAT,
 	TUPLE_PACK,
-	TUPLE_PACK_VERSIONSTAMPED_KEY,
-	TUPLE_PACK_VERSIONSTAMPED_VALUE,
+	TUPLE_PACK_WITH_VERSIONSTAMP,
 	TUPLE_UNPACK,
 	TUPLE_RANGE,
 	TUPLE_SORT,
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java b/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
index 9374c0d4d06..2367c1fdc08 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/StackTester.java
@@ -321,7 +321,7 @@ else if(op == StackOperation.TUPLE_PACK) {
 				//System.out.println(inst.context.preStr + " - " + " -> result '" + ByteArrayUtil.printable(coded) + "'");
 				inst.push(coded);
 			}
-			else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_VALUE) {
+			else if(op == StackOperation.TUPLE_PACK_WITH_VERSIONSTAMP) {
 				List<Object> params = inst.popParams(2).join();
 				byte[] prefix = (byte[])params.get(0);
 				int tupleSize = StackUtils.getInt(params.get(1));
@@ -331,12 +331,7 @@ else if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY || op == StackOperati
 					inst.push("ERROR: NONE".getBytes());
 				} else {
 					try {
-						byte[] coded;
-						if(op == StackOperation.TUPLE_PACK_VERSIONSTAMPED_KEY) {
-							coded = tuple.packVersionstampedKey(prefix);
-						} else {
-							coded = tuple.packVersionstampedValue(prefix);
-						}
+						byte[] coded = tuple.packWithVersionstamp(prefix);
 						inst.push("OK".getBytes());
 						inst.push(coded);
 					} catch (IllegalArgumentException e) {
diff --git a/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java b/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
index 9c6358d3756..556e92085e8 100644
--- a/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
+++ b/bindings/java/src/test/com/apple/foundationdb/test/VersionstampSmokeTest.java
@@ -42,7 +42,7 @@ public static void main(String[] args) {
 			CompletableFuture<byte[]> trVersionFuture = db.run((Transaction tr) -> {
 				// The incomplete Versionstamp will have tr's version information when committed.
 				Tuple t = Tuple.from("prefix", Versionstamp.incomplete());
-				tr.mutate(MutationType.SET_VERSIONSTAMPED_KEY, t.packVersionstampedKey(), new byte[0]);
+				tr.mutate(MutationType.SET_VERSIONSTAMPED_KEY, t.packWithVersionstamp(), new byte[0]);
 				return tr.getVersionstamp();
 			});
 
diff --git a/bindings/python/fdb/tuple.py b/bindings/python/fdb/tuple.py
index 52237f6accf..737d468dfee 100644
--- a/bindings/python/fdb/tuple.py
+++ b/bindings/python/fdb/tuple.py
@@ -374,7 +374,7 @@ def _encode(value, nested=False):
 #  * if there is exactly one incomplete versionstamp member, it returns the tuple with the
 #    two extra version bytes and the position of the version start
 #  * if there is more than one incomplete versionstamp member, it throws an error
-def _pack_maybe_with_versionstamp(t, prefix=None, for_value=False):
+def _pack_maybe_with_versionstamp(t, prefix=None):
     if not isinstance(t, tuple):
         raise Exception("fdbtuple pack() expects a tuple, got a " + str(type(t)))
 
@@ -384,10 +384,10 @@ def _pack_maybe_with_versionstamp(t, prefix=None, for_value=False):
     if version_pos >= 0:
         version_pos += len(prefix) if prefix is not None else 0
         bytes_list.extend(child_bytes)
-        if for_value:
-            bytes_list.append(struct.pack('<L', version_pos))
-        else:
+        if fdb.is_api_version_selected() and fdb.get_api_version() < 520:
             bytes_list.append(struct.pack('<H', version_pos))
+        else:
+            bytes_list.append(struct.pack('<L', version_pos))
     else:
         bytes_list.extend(child_bytes)
 
@@ -402,24 +402,14 @@ def pack(t, prefix=None):
     return res
 
 
-# packs the specified tuple into a key or value for versionstamp operations
-def pack_with_versionstamp(t, prefix=None, for_value=False):
-    res, version_pos = _pack_maybe_with_versionstamp(t, prefix=prefix, for_value=for_value)
+# packs the specified tuple into a key for versionstamp operations
+def pack_with_versionstamp(t, prefix=None):
+    res, version_pos = _pack_maybe_with_versionstamp(t, prefix)
     if version_pos < 0:
         raise ValueError("No incomplete versionstamp included in tuple pack with versionstamp")
     return res
 
 
-# packs the specified tuple into a key for versionstamp operations
-def pack_versionstamped_key(t, prefix=None):
-    return pack_with_versionstamp(t, prefix, for_value=False)
-
-
-# packs the specified tuple into a value for versionstamp operations
-def pack_versionstamped_value(t, prefix=None):
-    return pack_with_versionstamp(t, prefix, for_value=True)
-
-
 # unpacks the specified key into a tuple
 def unpack(key, prefix_len=0):
     pos = prefix_len
diff --git a/bindings/python/tests/tester.py b/bindings/python/tests/tester.py
index 70e99d3ee36..57002d5bd6f 100644
--- a/bindings/python/tests/tester.py
+++ b/bindings/python/tests/tester.py
@@ -32,14 +32,7 @@
 
 sys.path[:0] = [os.path.join(os.path.dirname(__file__), '..')]
 import fdb
-
-assert not fdb.is_api_version_selected()
-try:
-    fdb.get_api_version()
-except RuntimeError as e:
-    assert str(e) == 'API version is not set'
 fdb.api_version(int(sys.argv[2]))
-assert int(sys.argv[2]) == fdb.get_api_version()
 
 from fdb import six
 from fdb.impl import strinc
@@ -467,7 +460,7 @@ def run(self):
                     count = inst.pop()
                     items = inst.pop(count)
                     inst.push(fdb.tuple.pack(tuple(items)))
-                elif inst.op == six.u("TUPLE_PACK_VERSIONSTAMPED_KEY"):
+                elif inst.op == six.u("TUPLE_PACK_WITH_VERSIONSTAMP"):
                     prefix = inst.pop()
                     count = inst.pop()
                     items = inst.pop(count)
@@ -475,23 +468,7 @@ def run(self):
                         inst.push(b"ERROR: NONE")
                     else:
                         try:
-                            packed = fdb.tuple.pack_versionstamped_key(tuple(items), prefix=prefix)
-                            inst.push(b"OK")
-                            inst.push(packed)
-                        except ValueError as e:
-                            if str(e).startswith("No incomplete"):
-                                inst.push(b"ERROR: NONE")
-                            else:
-                                inst.push(b"ERROR: MULTIPLE")
-                elif inst.op == six.u("TUPLE_PACK_VERSIONSTAMPED_VALUE"):
-                    prefix = inst.pop()
-                    count = inst.pop()
-                    items = inst.pop(count)
-                    if not fdb.tuple.has_incomplete_versionstamp(items) and random.random() < 0.5:
-                        inst.push(b"ERROR: NONE")
-                    else:
-                        try:
-                            packed = fdb.tuple.pack_versionstamped_value(tuple(items), prefix=prefix)
+                            packed = fdb.tuple.pack_with_versionstamp(tuple(items), prefix=prefix)
                             inst.push(b"OK")
                             inst.push(packed)
                         except ValueError as e:
@@ -544,19 +521,6 @@ def run(self):
                     Tester.wait_empty(self.db, prefix)
                     inst.push(b"WAITED_FOR_EMPTY")
                 elif inst.op == six.u("UNIT_TESTS"):
-                    assert fdb.is_api_version_selected()
-                    api_version = fdb.get_api_version()
-                    try:
-                        fdb.api_version(api_version + 1)
-                        raise RuntimeError('Was not stopped from selecting two API versions')
-                    except RuntimeError as e:
-                        assert str(e) == 'FDB API already loaded at version {}'.format(api_version)
-                    try:
-                        fdb.api_version(api_version - 1)
-                        raise RuntimeError('Was not stopped from selecting two API versions')
-                    except RuntimeError as e:
-                        assert str(e) == 'FDB API already loaded at version {}'.format(api_version)
-                    fdb.api_version(api_version)
                     try:
                         db.options.set_location_cache_size(100001)
 
diff --git a/fdbclient/vexillographer/fdb.options b/fdbclient/vexillographer/fdb.options
index 7486b317741..37ac77f5978 100644
--- a/fdbclient/vexillographer/fdb.options
+++ b/fdbclient/vexillographer/fdb.options
@@ -230,10 +230,10 @@ description is not currently required but encouraged.
             description="Performs a little-endian comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored in the database. If the existing value in the database is shorter than ``param``, it is first extended to the length of ``param`` with zero bytes.  If ``param`` is shorter than the existing value in the database, the existing value is truncated to match the length of ``param``. The smaller of the two values is then stored in the database."/>
     <Option name="set_versionstamped_key" code="14"
             paramType="Bytes" paramDescription="value to which to set the transformed key"
-            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. They are also not currently compatible with the Subspace and Directory layer except in those languages and only in instances where they have already been set. Also, note that prior to API version 520, the offset was computed from only the final two bytes rather than the final four bytes." />
+            description="Transforms ``key`` using a versionstamp for the transaction. Sets the transformed key in the database to ``param``. The key is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the key from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the key is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the offset was computed from only the final two bytes rather than the final four bytes." />
     <Option name="set_versionstamped_value" code="15"
             paramType="Bytes" paramDescription="value to versionstamp and set"
-            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from the key and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps values are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the versionstamp was always placed at the beginning of the parameter rather than computing an offset." />
+            description="Transforms ``param`` using a versionstamp for the transaction. Sets the ``key`` given to the transformed ``param``. The parameter is transformed by removing the final four bytes from ``param`` and reading those as a little-Endian 32-bit integer to get a position ``pos``. The 10 bytes of the parameter from ``pos`` to ``pos + 10`` are replaced with the versionstamp of the transaction used. The first byte of the parameter is position 0. A versionstamp is a 10 byte, unique, monotonically (but not sequentially) increasing value for each committed transaction. The first 8 bytes are the committed version of the database (serialized in big-Endian order). The last 2 bytes are monotonic in the serialization order for transactions. WARNING: At this time, versionstamps are compatible with the Tuple layer only in the Java and Python bindings. Also, note that prior to API version 520, the versionstamp was always placed at the beginning of the parameter rather than computing an offset." />
     <Option name="byte_min" code="16"
             paramType="Bytes" paramDescription="value to check against database value"
             description="Performs lexicographic comparison of byte strings. If the existing value in the database is not present, then ``param`` is stored. Otherwise the smaller of the two values is then stored in the database."/>
diff --git a/fdbserver/MasterProxyServer.actor.cpp b/fdbserver/MasterProxyServer.actor.cpp
index a3f44575536..90de7dff7c0 100644
--- a/fdbserver/MasterProxyServer.actor.cpp
+++ b/fdbserver/MasterProxyServer.actor.cpp
@@ -244,10 +244,10 @@ struct ResolutionRequestBuilder {
 		bool isTXNStateTransaction = false;
 		for (auto & m : trIn.mutations) {
 			if (m.type == MutationRef::SetVersionstampedKey) {
-                transformVersionstampMutation( m, &MutationRef::param1, requests[0].version, transactionNumberInBatch );
+				transformVersionstampMutation( m, &MutationRef::param1, requests[0].version, transactionNumberInBatch );
 				trIn.write_conflict_ranges.push_back( requests[0].arena, singleKeyRange( m.param1, requests[0].arena ) );
 			} else if (m.type == MutationRef::SetVersionstampedValue) {
-                transformVersionstampMutation( m, &MutationRef::param2, requests[0].version, transactionNumberInBatch );
+				transformVersionstampMutation( m, &MutationRef::param2, requests[0].version, transactionNumberInBatch );
 			}
 			if (isMetadataMutation(m)) {
 				isTXNStateTransaction = true;

From 8de914a81fe02ab0f788eb88740f51371df28d92 Mon Sep 17 00:00:00 2001
From: Alec Grieser <agrieser@apple.com>
Date: Wed, 9 May 2018 09:01:22 -0700
Subject: [PATCH 7/7] use contents() instead of address of in withPrefix and
 withSuffix ; whitespace fixes

---
 fdbclient/NativeAPI.actor.cpp | 4 ++--
 flow/Arena.h                  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index 75fe22f1431..780b1c86c68 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -2063,8 +2063,8 @@ void Transaction::atomicOp(const KeyRef& key, const ValueRef& operand, MutationR
 
 	auto &req = tr;
 	auto &t = req.transaction;
-    auto r = singleKeyRange( key, req.arena );
-    auto v = ValueRef( req.arena, operand );
+	auto r = singleKeyRange( key, req.arena );
+	auto v = ValueRef( req.arena, operand );
 
 	t.mutations.push_back( req.arena, MutationRef( operationType, r.begin, v ) );
 
diff --git a/flow/Arena.h b/flow/Arena.h
index ea4cd392434..29505e7e641 100644
--- a/flow/Arena.h
+++ b/flow/Arena.h
@@ -438,13 +438,13 @@ class StringRef {
 
 	Standalone<StringRef> withPrefix( const StringRef& prefix ) const {
 		Standalone<StringRef> r;
-		((StringRef &)r) = withPrefix(prefix, r.arena());
+		r.contents() = withPrefix(prefix, r.arena());
 		return r;
 	}
 
 	Standalone<StringRef> withSuffix( const StringRef& suffix ) const {
 		Standalone<StringRef> r;
-		((StringRef &)r) = withSuffix(suffix, r.arena());
+		r.contents() = withSuffix(suffix, r.arena());
 		return r;
 	}