diff --git a/src/mapper/java/org/codehaus/jackson/map/ObjectMapper.java b/src/mapper/java/org/codehaus/jackson/map/ObjectMapper.java
index c6bcb55..bfd18da 100644
--- a/src/mapper/java/org/codehaus/jackson/map/ObjectMapper.java
+++ b/src/mapper/java/org/codehaus/jackson/map/ObjectMapper.java
@@ -1779,7 +1779,6 @@
         if (deser != null) {
             return deser;
         }
-
         // Nope: need to ask provider to resolve it
         deser = _deserializerProvider.findTypedValueDeserializer(cfg, valueType);
         if (deser == null) { // can this happen?
diff --git a/src/mapper/java/org/codehaus/jackson/map/deser/UntypedObjectDeserializer.java b/src/mapper/java/org/codehaus/jackson/map/deser/UntypedObjectDeserializer.java
index 4de483e..507d930 100644
--- a/src/mapper/java/org/codehaus/jackson/map/deser/UntypedObjectDeserializer.java
+++ b/src/mapper/java/org/codehaus/jackson/map/deser/UntypedObjectDeserializer.java
@@ -8,9 +8,9 @@
 import org.codehaus.jackson.JsonToken;
 import org.codehaus.jackson.map.DeserializationConfig;
 import org.codehaus.jackson.map.DeserializationContext;
-import org.codehaus.jackson.map.JsonMappingException;
 import org.codehaus.jackson.map.TypeDeserializer;
 import org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import org.codehaus.jackson.map.util.ObjectBuffer;
 
 /**
  * This deserializer is only used if it is necessary to bind content of
@@ -143,30 +143,67 @@
     protected List<Object> mapArray(JsonParser jp, DeserializationContext ctxt)
         throws IOException, JsonProcessingException
     {
-        ArrayList<Object> result = new ArrayList<Object>();
-        while (jp.nextToken() != JsonToken.END_ARRAY) {
-            result.add(deserialize(jp, ctxt));
+        // Minor optimization to handle small lists (default size for ArrayList is 10)
+        if (jp.nextToken()  == JsonToken.END_ARRAY) {
+            return new ArrayList<Object>(4);
         }
+        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
+        Object[] values = buffer.resetAndStart();
+        int ptr = 0;
+        int totalSize = 0;
+        do {
+            Object value = deserialize(jp, ctxt);
+            ++totalSize;
+            if (ptr >= values.length) {
+                values = buffer.appendCompletedChunk(values);
+                ptr = 0;
+            }
+            values[ptr++] = value;
+        } while (jp.nextToken() != JsonToken.END_ARRAY);
+        // let's create almost full array, with 1/8 slack
+        ArrayList<Object> result = new ArrayList<Object>(totalSize + (totalSize >> 3) + 1);
+        buffer.completeAndClearBuffer(values, ptr, result);
         return result;
     }
 
     protected Map<String,Object> mapObject(JsonParser jp, DeserializationContext ctxt)
         throws IOException, JsonProcessingException
     {
-        LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>();
         JsonToken t = jp.getCurrentToken();
         if (t == JsonToken.START_OBJECT) {
             t = jp.nextToken();
         }
-        for (; t == JsonToken.FIELD_NAME; t = jp.nextToken()) {
+        // 1.6: minor optimization; let's handle 1 and 2 entry cases separately
+        if (t != JsonToken.FIELD_NAME) { // and empty one too
+            // empty map might work; but caller may want to modify... so better just give small modifiable
+            return new LinkedHashMap<String,Object>(4);
+        }
+        String field1 = jp.getText();
+        jp.nextToken();
+        Object value1 = deserialize(jp, ctxt);
+        if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable
+            LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4);
+            result.put(field1, value1);
+            return result;
+        }
+        String field2 = jp.getText();
+        jp.nextToken();
+        Object value2 = deserialize(jp, ctxt);
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4);
+            result.put(field1, value1);
+            result.put(field2, value2);
+            return result;
+        }
+        // And then the general case; default map size is 16
+        LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>();
+        result.put(field1, value1);
+        result.put(field2, value2);
+        do {
             String fieldName = jp.getText();
             jp.nextToken();
             result.put(fieldName, deserialize(jp, ctxt));
-        }
-        // sanity check
-        if (t != JsonToken.END_OBJECT) {
-                throw JsonMappingException.from(jp, "Unexpected token ("+t+"), expected END_OBJECT after JSON Object");
-        }
+        } while (jp.nextToken() != JsonToken.END_OBJECT);
         return result;
     }
 }
diff --git a/src/mapper/java/org/codehaus/jackson/map/util/ObjectBuffer.java b/src/mapper/java/org/codehaus/jackson/map/util/ObjectBuffer.java
index d0d7dea..2ebccad 100644
--- a/src/mapper/java/org/codehaus/jackson/map/util/ObjectBuffer.java
+++ b/src/mapper/java/org/codehaus/jackson/map/util/ObjectBuffer.java
@@ -1,6 +1,7 @@
 package org.codehaus.jackson.map.util;
 
 import java.lang.reflect.Array;
+import java.util.List;
 
 /**
  * Helper class to use for constructing Object arrays by appending entries
@@ -31,15 +32,15 @@
 
     // // // Data storage
 
-    Node _bufferHead;
+    private Node _bufferHead;
 
-    Node _bufferTail;
+    private Node _bufferTail;
 
     /**
      * Number of total buffered entries in this buffer, counting all instances
      * within linked list formed by following {@link #_bufferHead}.
      */
-    int _bufferedEntryCount;
+    private int _bufferedEntryCount;
 
     // // // Simple reuse
 
@@ -47,20 +48,20 @@
      * Reusable Object array, stored here after buffer has been released having
      * been used previously.
      */
-    Object[] _freeBuffer;
+    private Object[] _freeBuffer;
 
     /*
-    ////////////////////////////////////////////////////////////////////////
-    // Construction
-    ////////////////////////////////////////////////////////////////////////
+    /**********************************************************
+    /* Construction
+    /**********************************************************
      */
 
     public ObjectBuffer() { }
 
     /*
-    ////////////////////////////////////////////////////////////////////////
-    // Public API
-    ////////////////////////////////////////////////////////////////////////
+    /**********************************************************
+    /* Public API
+    /**********************************************************
      */
 
     /**
@@ -147,6 +148,25 @@
     }
 
     /**
+     * Another
+     * 
+     * @since 1.6
+     */
+    public void completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, List<Object> resultList)
+    {
+        for (Node n = _bufferHead; n != null; n = n.next()) {
+            Object[] curr = n.getData();
+            for (int i = 0, len = curr.length; i < len; ++i) {
+                resultList.add(curr[i]);
+            }
+        }
+        // and then the last one
+        for (int i = 0; i < lastChunkEntries; ++i) {
+            resultList.add(lastChunk[i]);
+        }
+    }
+    
+    /**
      * Helper method that can be used to check how much free capacity
      * will this instance start with. Can be used to choose the best
      * instance to reuse, based on size of reusable object chunk
@@ -164,9 +184,9 @@
     public int bufferedSize() { return _bufferedEntryCount; }
 
     /*
-    ////////////////////////////////////////////////////////////////////////
-    // Internal methods
-    ////////////////////////////////////////////////////////////////////////
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
      */
 
     protected void _reset()
@@ -201,9 +221,9 @@
     }
 
     /*
-    ////////////////////////////////////////////////////////////////////////
-    // Helper classes
-    ////////////////////////////////////////////////////////////////////////
+    /**********************************************************
+    /* Helper classes
+    /**********************************************************
      */
 
     /**
diff --git a/src/perf/TestJsonPerf.java b/src/perf/TestJsonPerf.java
index 1bee97b..dfe49ee 100644
--- a/src/perf/TestJsonPerf.java
+++ b/src/perf/TestJsonPerf.java
@@ -59,7 +59,7 @@
         while (true) {
             try {  Thread.sleep(100L); } catch (InterruptedException ie) { }
             // Use 9 to test all...
-            int round = (i++ % 1);
+            int round = (i++ % 2);
 
             long curr = System.currentTimeMillis();
             String msg;
diff --git a/src/smile/java/org/codehaus/jackson/smile/SmileParser.java b/src/smile/java/org/codehaus/jackson/smile/SmileParser.java
index 53e2e10..b844aec 100644
--- a/src/smile/java/org/codehaus/jackson/smile/SmileParser.java
+++ b/src/smile/java/org/codehaus/jackson/smile/SmileParser.java
@@ -652,8 +652,9 @@
         char[] outBuf = _textBuffer.emptyAndGetCurrentSegment();
         int inPtr = _inputPtr;
         _inputPtr += len;
+        final byte[] inBuf = _inputBuffer;
         for (int end = inPtr + len; inPtr < end; ) {
-            outBuf[outPtr++] = (char) _inputBuffer[inPtr++];
+            outBuf[outPtr++] = (char) inBuf[inPtr++];
         }
         _textBuffer.setCurrentLength(len);
         return _textBuffer.contentsAsString();
@@ -674,25 +675,26 @@
         int inPtr = _inputPtr;
         _inputPtr += len;
         final int[] codes = SmileConstants.sUtf8UnitLengths;
+        final byte[] inBuf = _inputBuffer;
         for (int end = inPtr + len; inPtr < end; ) {
-            int i = _inputBuffer[inPtr++] & 0xFF;
+            int i = inBuf[inPtr++] & 0xFF;
             int code = codes[i];
             if (code != 0) {
                 // trickiest one, need surrogate handling
                 switch (code) {
                 case 1:
-                    i = ((i & 0x1F) << 6) | (_inputBuffer[inPtr++] & 0x3F);
+                    i = ((i & 0x1F) << 6) | (inBuf[inPtr++] & 0x3F);
                     break;
                 case 2:
                     i = ((i & 0x0F) << 12)
-                        | ((_inputBuffer[inPtr++] & 0x3F) << 6)
-                        | (_inputBuffer[inPtr++] & 0x3F);
+                        | ((inBuf[inPtr++] & 0x3F) << 6)
+                        | (inBuf[inPtr++] & 0x3F);
                     break;
                 case 3:
                     i = ((i & 0x07) << 18)
-                    | ((_inputBuffer[inPtr++] & 0x3F) << 12)
-                    | ((_inputBuffer[inPtr++] & 0x3F) << 6)
-                    | (_inputBuffer[inPtr++] & 0x3F);
+                    | ((inBuf[inPtr++] & 0x3F) << 12)
+                    | ((inBuf[inPtr++] & 0x3F) << 6)
+                    | (inBuf[inPtr++] & 0x3F);
                     // note: this is the codepoint value; need to split, too
                     i -= 0x10000;
                     outBuf[outPtr++] = (char) (0xD800 | (i >> 10));
@@ -778,29 +780,29 @@
     	int inPtr = _inputPtr;
     	final byte[] inBuf = _inputBuffer;
         do {
-			int q = inBuf[inPtr++] << 8;
-			q |= inBuf[inPtr++];
-			q <<= 8;
-			q |= inBuf[inPtr++];
-			q <<= 8;
-			q |= inBuf[inPtr++];
-			_quadBuffer[offset++] = q;
+            int q = inBuf[inPtr++] << 8;
+            q |= inBuf[inPtr++];
+            q <<= 8;
+            q |= inBuf[inPtr++];
+            q <<= 8;
+            q |= inBuf[inPtr++];
+            _quadBuffer[offset++] = q;
         } while ((len -= 4) > 3);
         // and then leftovers
         if (len > 0) {
-			int q = inBuf[inPtr++];
-			if (--len >= 0) {
-				q = (q << 8) + inBuf[inPtr++];				
-				if (--len >= 0) {
-					q = (q << 8) + inBuf[inPtr++];				
-				}
-			}
-			_quadBuffer[offset++] = q;
+            int q = inBuf[inPtr++];
+            if (--len >= 0) {
+                q = (q << 8) + inBuf[inPtr++];				
+                if (--len >= 0) {
+                    q = (q << 8) + inBuf[inPtr++];				
+                }
+            }
+            _quadBuffer[offset++] = q;
         }
         return _symbols.findName(_quadBuffer, offset);
-	}
+    }
     
-    public static int[] _growArrayTo(int[] arr, int minSize)
+    private static int[] _growArrayTo(int[] arr, int minSize)
     {
     	int[] newArray = new int[minSize + 4];
         if (arr != null) {
@@ -867,9 +869,9 @@
             case 4: // VInt (zigzag) or BigDecimal
             	int subtype = tb & 0x03;
             	if (subtype == 0) { // (v)int
-            		_finishInt();
+            	    _finishInt();
             	} else if (subtype == 1) { // (v)long
-            		_finishLong();
+            	    _finishLong();
             	} else if (subtype == 2) {
                     _finishBigInteger();
             	} else {
@@ -879,14 +881,14 @@
             case 5: // other numbers
             	switch (tb & 0x03) {
             	case 0: // float
-            		_finishFloat();
-            		return;
+            	    _finishFloat();
+            	    return;
             	case 1: // double
-            		_finishDouble();
-            		return;
+            	    _finishDouble();
+            	    return;
             	case 2: // big-decimal
-            		_finishBigDecimal();
-            		return;
+            	    _finishBigDecimal();
+            	    return;
             	}
             	break;
             }
@@ -910,36 +912,36 @@
     	if (value < 0) { // 6 bits
     		value &= 0x3F;
     	} else {
-	    	if (_inputPtr >= _inputEnd) {
-	    		loadMoreGuaranteed();
-	    	}
-	    	i = _inputBuffer[_inputPtr++];
-	    	if (i >= 0) { // 13 bits
-		    	value = (value << 7) + i;
-		    	if (_inputPtr >= _inputEnd) {
-					loadMoreGuaranteed();
-				}
-				i = _inputBuffer[_inputPtr++];
-				if (i >= 0) {
-					value = (value << 7) + i;
-					if (_inputPtr >= _inputEnd) {
-						loadMoreGuaranteed();
-					}
-					i = _inputBuffer[_inputPtr++];
-					if (i >= 0) {
-						value = (value << 7) + i;
-						// and then we must get negative
-						if (_inputPtr >= _inputEnd) {
-							loadMoreGuaranteed();
-						}
-						i = _inputBuffer[_inputPtr++];
-						if (i >= 0) {
-							_reportError("Corrupt input; 32-bit VInt extends beyond 5 data bytes");
-						}
-					}
-				}
-	    	}
-	        value = (value << 6) + (i & 0x3F);
+    	    if (_inputPtr >= _inputEnd) {
+    	        loadMoreGuaranteed();
+    	    }
+    	    i = _inputBuffer[_inputPtr++];
+    	    if (i >= 0) { // 13 bits
+    	        value = (value << 7) + i;
+    	        if (_inputPtr >= _inputEnd) {
+    	            loadMoreGuaranteed();
+    	        }
+    	        i = _inputBuffer[_inputPtr++];
+    	        if (i >= 0) {
+    	            value = (value << 7) + i;
+    	            if (_inputPtr >= _inputEnd) {
+    	                loadMoreGuaranteed();
+    	            }
+    	            i = _inputBuffer[_inputPtr++];
+    	            if (i >= 0) {
+    	                value = (value << 7) + i;
+    	                // and then we must get negative
+    	                if (_inputPtr >= _inputEnd) {
+    	                    loadMoreGuaranteed();
+    	                }
+    	                i = _inputBuffer[_inputPtr++];
+    	                if (i >= 0) {
+    	                    _reportError("Corrupt input; 32-bit VInt extends beyond 5 data bytes");
+    	                }
+    	            }
+    	        }
+    	    }
+    	    value = (value << 6) + (i & 0x3F);
     	}
         _numberInt = SmileUtil.zigzagDecode(value);
     	_numTypesValid = NR_INT;
@@ -952,17 +954,17 @@
 	long l = (long) _fourBytesToInt();
     	// and loop for the rest
     	while (true) {
-        	if (_inputPtr >= _inputEnd) {
-        	    loadMoreGuaranteed();
-        	}
-        	int value = _inputBuffer[_inputPtr++];
-        	if (value < 0) {
-        		l = (l << 6) + (value & 0x3F);
-        		_numberLong = SmileUtil.zigzagDecode(l);
-        		_numTypesValid = NR_LONG;
-        		return;
-        	}
-        	l = (l << 7) + value;
+    	    if (_inputPtr >= _inputEnd) {
+    	        loadMoreGuaranteed();
+    	    }
+    	    int value = _inputBuffer[_inputPtr++];
+    	    if (value < 0) {
+    	        l = (l << 6) + (value & 0x3F);
+    	        _numberLong = SmileUtil.zigzagDecode(l);
+    	        _numTypesValid = NR_LONG;
+    	        return;
+    	    }
+    	    l = (l << 7) + value;
     	}
     }
 
@@ -1118,14 +1120,12 @@
         }
         int outPtr = 0;
         // Note: we count on fact that buffer must have at least 'len' (<= 64) empty char slots
-	char[] outBuf = _textBuffer.emptyAndGetCurrentSegment();
+	final char[] outBuf = _textBuffer.emptyAndGetCurrentSegment();
 	int inPtr = _inputPtr;
 	_inputPtr += len;
-if (_inputPtr > _inputEnd) {
-    throw new Error("Bad stuff; ptr now "+_inputPtr+"...");
-}
+	final byte[] inputBuf = _inputBuffer;
 	for (int end = inPtr + len; inPtr < end; ) {
-	    outBuf[outPtr++] = (char) _inputBuffer[inPtr++];
+	    outBuf[outPtr++] = (char) inputBuf[inPtr++];
 	}
 	_textBuffer.setCurrentLength(len);
     }
@@ -1141,32 +1141,33 @@
         int inPtr = _inputPtr;
         _inputPtr += len;
         final int[] codes = SmileConstants.sUtf8UnitLengths;
+        final byte[] inputBuf = _inputBuffer;
         for (int end = inPtr + len; inPtr < end; ) {
-            int i = _inputBuffer[inPtr++] & 0xFF;
+            int i = inputBuf[inPtr++] & 0xFF;
             int code = codes[i];
             if (code != 0) {
                 // trickiest one, need surrogate handling
                 switch (code) {
                 case 1:
-                    i = ((i & 0x1F) << 6) | (_inputBuffer[inPtr++] & 0x3F);
+                    i = ((i & 0x1F) << 6) | (inputBuf[inPtr++] & 0x3F);
                     break;
 	        case 2:
 	            i = ((i & 0x0F) << 12)
-	                  | ((_inputBuffer[inPtr++] & 0x3F) << 6)
-	                    | (_inputBuffer[inPtr++] & 0x3F);
-	                break;
+	                  | ((inputBuf[inPtr++] & 0x3F) << 6)
+	                  | (inputBuf[inPtr++] & 0x3F);
+	            break;
 	        case 3:
-	                i = ((i & 0x07) << 18)
-	                | ((_inputBuffer[inPtr++] & 0x3F) << 12)
-	                | ((_inputBuffer[inPtr++] & 0x3F) << 6)
-	                | (_inputBuffer[inPtr++] & 0x3F);
-	                // note: this is the codepoint value; need to split, too
-	                i -= 0x10000;
-	                outBuf[outPtr++] = (char) (0xD800 | (i >> 10));
-	                i = 0xDC00 | (i & 0x3FF);
-	                break;
+	            i = ((i & 0x07) << 18)
+	                | ((inputBuf[inPtr++] & 0x3F) << 12)
+	                | ((inputBuf[inPtr++] & 0x3F) << 6)
+	                | (inputBuf[inPtr++] & 0x3F);
+	            // note: this is the codepoint value; need to split, too
+	            i -= 0x10000;
+	            outBuf[outPtr++] = (char) (0xD800 | (i >> 10));
+	            i = 0xDC00 | (i & 0x3FF);
+	            break;
 	        default: // invalid
-	                _reportError("Invalid byte "+Integer.toHexString(i)+" in short Unicode text block");
+	            _reportError("Invalid byte "+Integer.toHexString(i)+" in short Unicode text block");
                 }
 	    }
 	    outBuf[outPtr++] = (char) i;
@@ -1184,19 +1185,22 @@
             if (_inputPtr >= _inputEnd) {
                 loadMoreGuaranteed();
             }
-            int left = _inputEnd - _inputPtr;
+            int inPtr = _inputPtr;
+            int left = _inputEnd - inPtr;
             if (outPtr >= outBuf.length) {
                 outBuf = _textBuffer.finishCurrentSegment();
                 outPtr = 0;
             }
             left = Math.min(left, outBuf.length - outPtr);
             do {
-                byte b = _inputBuffer[_inputPtr++];
+                byte b = _inputBuffer[inPtr++];
                 if (b == SmileConstants.BYTE_MARKER_END_OF_STRING) {
+                    _inputPtr = inPtr;
                     break main_loop;
                 }
                 outBuf[outPtr++] = (char) b;	    		
             } while (--left > 0);
+            _inputPtr = inPtr;
         }
         _textBuffer.setCurrentLength(outPtr);
     }
@@ -1340,17 +1344,16 @@
             	 * (note: can potentially skip invalid UTF-8 too)
             	 */
             	while (true) {
-            		final int end = _inputEnd;
-            		final byte[] buf = _inputBuffer;
-            		while (_inputPtr < end) {
-            			if (buf[_inputPtr++] == BYTE_MARKER_END_OF_STRING) {
-            				return;
-            			}
-            		}
-            		loadMoreGuaranteed();
+            	    final int end = _inputEnd;
+            	    final byte[] buf = _inputBuffer;
+            	    while (_inputPtr < end) {
+            	        if (buf[_inputPtr++] == BYTE_MARKER_END_OF_STRING) {
+            	            return;
+            	        }
+            	    }
+            	    loadMoreGuaranteed();
             	}
-
-            	//
+            	// never gets here
             case 2: // binary, raw
                 _skipBytes(_readUnsignedVInt());
                 return;