Fix conflict

diff --cc basis/byte-vectors/byte-vectors.factor
index 0000000000000000000000000000000000000000,e24c808bbc79e91d299a77f97ac17564c61465b5..d146017db08d636d5022f64fbf833e67f562e376
mode 000000,100644..100644
--- /dev/null
--- 2/basis/byte-vectors/byte-vectors.factor
+++ b/basis/byte-vectors/byte-vectors.factor
@@@ -1,0 -1,51 +1,51 @@@
 -    <byte-array> 0 byte-vector boa ; inline\r
+ ! Copyright (C) 2008 Slava Pestov.\r
+ ! See http://factorcode.org/license.txt for BSD license.\r
+ USING: arrays kernel kernel.private math sequences\r
+ sequences.private growable byte-arrays accessors parser\r
+ prettyprint.custom ;\r
+ IN: byte-vectors\r
+ \r
+ TUPLE: byte-vector\r
+ { underlying byte-array }\r
+ { length array-capacity } ;\r
+ \r
+ : <byte-vector> ( n -- byte-vector )\r
 -    drop [ <byte-array> ] [ >fixnum ] bi byte-vector boa ;\r
++    (byte-array) 0 byte-vector boa ; inline\r
+ \r
+ : >byte-vector ( seq -- byte-vector )\r
+     T{ byte-vector f B{ } 0 } clone-like ;\r
+ \r
+ M: byte-vector like\r
+     drop dup byte-vector? [\r
+         dup byte-array?\r
+         [ dup length byte-vector boa ] [ >byte-vector ] if\r
+     ] unless ;\r
+ \r
+ M: byte-vector new-sequence\r
++    drop [ (byte-array) ] [ >fixnum ] bi byte-vector boa ;\r
+ \r
+ M: byte-vector equal?\r
+     over byte-vector? [ sequence= ] [ 2drop f ] if ;\r
+ \r
+ M: byte-array like\r
+     #! If we have an byte-array, we're done.\r
+     #! If we have a byte-vector, and it's at full capacity,\r
+     #! we're done. Otherwise, call resize-byte-array, which is a\r
+     #! relatively fast primitive.\r
+     drop dup byte-array? [\r
+         dup byte-vector? [\r
+             [ length ] [ underlying>> ] bi\r
+             2dup length eq?\r
+             [ nip ] [ resize-byte-array ] if\r
+         ] [ >byte-array ] if\r
+     ] unless ;\r
+ \r
+ M: byte-array new-resizable drop <byte-vector> ;\r
+ \r
+ : BV{ \ } [ >byte-vector ] parse-literal ; parsing\r
+ \r
+ M: byte-vector pprint* pprint-object ;\r
+ M: byte-vector pprint-delims drop \ BV{ \ } ;\r
+ M: byte-vector >pprint-sequence ;\r
+ \r
+ INSTANCE: byte-vector growable\r

diff --cc basis/compiler/cfg/intrinsics/intrinsics.factor
Simple merge

diff --cc basis/specialized-arrays/functor/functor.factor
Simple merge

diff --cc basis/stack-checker/known-words/known-words.factor
Simple merge

diff --cc basis/tools/walker/walker.factor
Simple merge

diff --cc core/bootstrap/primitives.factor
Simple merge

diff --cc core/sequences/sequences-docs.factor
Simple merge

diff --cc core/sequences/sequences.factor
Simple merge

diff --cc vm/types.c
Simple merge

diff --cc vm/types.h
index d8d69dc5415e69bb92792ddab1dd427fc47bfb33,ba8d9689fe8b810c5c02ddc25944b2cebc44fba2..5850489a4c1ae5bb07c3a17ff88b09443a51530a
--- 1/vm/types.h
--- 2/vm/types.h
+++ b/vm/types.h
@@@ -116,19 -116,17 +116,19 @@@ void primitive_tuple(void)
  void primitive_tuple_boa(void);
  void primitive_tuple_layout(void);
  void primitive_byte_array(void);
 +void primitive_uninitialized_byte_array(void);
  void primitive_clone(void);
  
- F_ARRAY *reallot_array(F_ARRAY* array, CELL capacity, CELL fill);
+ F_ARRAY *reallot_array(F_ARRAY* array, CELL capacity);
  F_BYTE_ARRAY *reallot_byte_array(F_BYTE_ARRAY *array, CELL capacity);
  void primitive_resize_array(void);
  void primitive_resize_byte_array(void);
  
  F_STRING* allot_string_internal(CELL capacity);
  F_STRING* allot_string(CELL capacity, CELL fill);
 +void primitive_uninitialized_string(void);
  void primitive_string(void);
- F_STRING *reallot_string(F_STRING *string, CELL capacity, CELL fill);
+ F_STRING *reallot_string(F_STRING *string, CELL capacity);
  void primitive_resize_string(void);
  
  F_STRING *memory_to_char_string(const char *string, CELL length);