[osmosis] 01/07: Add patch to update generated source for protobuf 2.6.0.

Bas Couwenberg sebastic at xs4all.nl
Sat Sep 27 19:47:35 UTC 2014


This is an automated email from the git hooks/post-receive script.

sebastic-guest pushed a commit to branch master
in repository osmosis.

commit 70d67bc57690baa10634282adeaad17d3b77158b
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date:   Sat Sep 27 20:35:56 2014 +0200

    Add patch to update generated source for protobuf 2.6.0.
---
 debian/changelog                       |     6 +
 debian/patches/05-protobuf-2.6.0.patch | 15432 +++++++++++++++++++++++++++++++
 debian/patches/series                  |     1 +
 3 files changed, 15439 insertions(+)

diff --git a/debian/changelog b/debian/changelog
index c1a0a5c..afcc81a 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+osmosis (0.43.1-2) UNRELEASED; urgency=medium
+
+  * Add patch to update generated source for protobuf 2.6.0.
+
+ -- Bas Couwenberg <sebastic at xs4all.nl>  Sat, 27 Sep 2014 20:35:14 +0200
+
 osmosis (0.43.1-1) unstable; urgency=medium
 
   [ Giovanni Mascellani ]
diff --git a/debian/patches/05-protobuf-2.6.0.patch b/debian/patches/05-protobuf-2.6.0.patch
new file mode 100644
index 0000000..07e66a5
--- /dev/null
+++ b/debian/patches/05-protobuf-2.6.0.patch
@@ -0,0 +1,15432 @@
+Description: Update generated source for protobuf 2.6.0 using osmosis-protoc.sh.
+Author: Bas Couwenberg <sebastic at xs4all.nl>
+
+--- a/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Fileformat.java
++++ b/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Fileformat.java
+@@ -8,98 +8,319 @@ public final class Fileformat {
+   public static void registerAllExtensions(
+       com.google.protobuf.ExtensionRegistryLite registry) {
+   }
+-  public interface BlobOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // optional bytes raw = 1;
++  public interface BlobOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.Blob)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>optional bytes raw = 1;</code>
++     *
++     * <pre>
++     * No compression
++     * </pre>
++     */
+     boolean hasRaw();
++    /**
++     * <code>optional bytes raw = 1;</code>
++     *
++     * <pre>
++     * No compression
++     * </pre>
++     */
+     com.google.protobuf.ByteString getRaw();
+-    
+-    // optional int32 raw_size = 2;
++
++    /**
++     * <code>optional int32 raw_size = 2;</code>
++     *
++     * <pre>
++     * When compressed, the uncompressed size
++     * </pre>
++     */
+     boolean hasRawSize();
++    /**
++     * <code>optional int32 raw_size = 2;</code>
++     *
++     * <pre>
++     * When compressed, the uncompressed size
++     * </pre>
++     */
+     int getRawSize();
+-    
+-    // optional bytes zlib_data = 3;
++
++    /**
++     * <code>optional bytes zlib_data = 3;</code>
++     *
++     * <pre>
++     * Possible compressed versions of the data.
++     * </pre>
++     */
+     boolean hasZlibData();
++    /**
++     * <code>optional bytes zlib_data = 3;</code>
++     *
++     * <pre>
++     * Possible compressed versions of the data.
++     * </pre>
++     */
+     com.google.protobuf.ByteString getZlibData();
+-    
+-    // optional bytes lzma_data = 4;
++
++    /**
++     * <code>optional bytes lzma_data = 4;</code>
++     *
++     * <pre>
++     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++     * </pre>
++     */
+     boolean hasLzmaData();
++    /**
++     * <code>optional bytes lzma_data = 4;</code>
++     *
++     * <pre>
++     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++     * </pre>
++     */
+     com.google.protobuf.ByteString getLzmaData();
+-    
+-    // optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];
++
++    /**
++     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++     *
++     * <pre>
++     * Formerly used for bzip2 compressed data. Depreciated in 2010.
++     * </pre>
++     */
+     @java.lang.Deprecated boolean hasOBSOLETEBzip2Data();
++    /**
++     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++     *
++     * <pre>
++     * Formerly used for bzip2 compressed data. Depreciated in 2010.
++     * </pre>
++     */
+     @java.lang.Deprecated com.google.protobuf.ByteString getOBSOLETEBzip2Data();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.Blob}
++   */
+   public static final class Blob extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements BlobOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.Blob)
++      BlobOrBuilder {
+     // Use Blob.newBuilder() to construct.
+-    private Blob(Builder builder) {
++    private Blob(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private Blob(boolean noInit) {}
+-    
++    private Blob(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final Blob defaultInstance;
+     public static Blob getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public Blob getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private Blob(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              bitField0_ |= 0x00000001;
++              raw_ = input.readBytes();
++              break;
++            }
++            case 16: {
++              bitField0_ |= 0x00000002;
++              rawSize_ = input.readInt32();
++              break;
++            }
++            case 26: {
++              bitField0_ |= 0x00000004;
++              zlibData_ = input.readBytes();
++              break;
++            }
++            case 34: {
++              bitField0_ |= 0x00000008;
++              lzmaData_ = input.readBytes();
++              break;
++            }
++            case 42: {
++              bitField0_ |= 0x00000010;
++              oBSOLETEBzip2Data_ = input.readBytes();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<Blob> PARSER =
++        new com.google.protobuf.AbstractParser<Blob>() {
++      public Blob parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new Blob(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<Blob> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // optional bytes raw = 1;
+     public static final int RAW_FIELD_NUMBER = 1;
+     private com.google.protobuf.ByteString raw_;
++    /**
++     * <code>optional bytes raw = 1;</code>
++     *
++     * <pre>
++     * No compression
++     * </pre>
++     */
+     public boolean hasRaw() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>optional bytes raw = 1;</code>
++     *
++     * <pre>
++     * No compression
++     * </pre>
++     */
+     public com.google.protobuf.ByteString getRaw() {
+       return raw_;
+     }
+-    
+-    // optional int32 raw_size = 2;
++
+     public static final int RAW_SIZE_FIELD_NUMBER = 2;
+     private int rawSize_;
++    /**
++     * <code>optional int32 raw_size = 2;</code>
++     *
++     * <pre>
++     * When compressed, the uncompressed size
++     * </pre>
++     */
+     public boolean hasRawSize() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional int32 raw_size = 2;</code>
++     *
++     * <pre>
++     * When compressed, the uncompressed size
++     * </pre>
++     */
+     public int getRawSize() {
+       return rawSize_;
+     }
+-    
+-    // optional bytes zlib_data = 3;
++
+     public static final int ZLIB_DATA_FIELD_NUMBER = 3;
+     private com.google.protobuf.ByteString zlibData_;
++    /**
++     * <code>optional bytes zlib_data = 3;</code>
++     *
++     * <pre>
++     * Possible compressed versions of the data.
++     * </pre>
++     */
+     public boolean hasZlibData() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>optional bytes zlib_data = 3;</code>
++     *
++     * <pre>
++     * Possible compressed versions of the data.
++     * </pre>
++     */
+     public com.google.protobuf.ByteString getZlibData() {
+       return zlibData_;
+     }
+-    
+-    // optional bytes lzma_data = 4;
++
+     public static final int LZMA_DATA_FIELD_NUMBER = 4;
+     private com.google.protobuf.ByteString lzmaData_;
++    /**
++     * <code>optional bytes lzma_data = 4;</code>
++     *
++     * <pre>
++     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++     * </pre>
++     */
+     public boolean hasLzmaData() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>optional bytes lzma_data = 4;</code>
++     *
++     * <pre>
++     * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++     * </pre>
++     */
+     public com.google.protobuf.ByteString getLzmaData() {
+       return lzmaData_;
+     }
+-    
+-    // optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];
++
+     public static final int OBSOLETE_BZIP2_DATA_FIELD_NUMBER = 5;
+     private com.google.protobuf.ByteString oBSOLETEBzip2Data_;
++    /**
++     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++     *
++     * <pre>
++     * Formerly used for bzip2 compressed data. Depreciated in 2010.
++     * </pre>
++     */
+     @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
+       return ((bitField0_ & 0x00000010) == 0x00000010);
+     }
++    /**
++     * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++     *
++     * <pre>
++     * Formerly used for bzip2 compressed data. Depreciated in 2010.
++     * </pre>
++     */
+     @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
+       return oBSOLETEBzip2Data_;
+     }
+-    
++
+     private void initFields() {
+       raw_ = com.google.protobuf.ByteString.EMPTY;
+       rawSize_ = 0;
+@@ -110,12 +331,13 @@ public final class Fileformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -134,13 +356,14 @@ public final class Fileformat {
+       if (((bitField0_ & 0x00000010) == 0x00000010)) {
+         output.writeBytes(5, oBSOLETEBzip2Data_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -162,106 +385,98 @@ public final class Fileformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeBytesSize(5, oBSOLETEBzip2Data_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Fileformat.Blob prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.Blob}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Fileformat.Blob, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Fileformat.BlobOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.Blob)
++        org.openstreetmap.osmosis.osmbinary.Fileformat.BlobOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         raw_ = com.google.protobuf.ByteString.EMPTY;
+@@ -276,15 +491,15 @@ public final class Fileformat {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob build() {
+         org.openstreetmap.osmosis.osmbinary.Fileformat.Blob result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -292,17 +507,7 @@ public final class Fileformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Fileformat.Blob buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Fileformat.Blob result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.Blob buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Fileformat.Blob result = new org.openstreetmap.osmosis.osmbinary.Fileformat.Blob(this);
+         int from_bitField0_ = bitField0_;
+@@ -330,7 +535,7 @@ public final class Fileformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Fileformat.Blob other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Fileformat.Blob.getDefaultInstance()) return this;
+         if (other.hasRaw()) {
+@@ -348,69 +553,62 @@ public final class Fileformat {
+         if (other.hasOBSOLETEBzip2Data()) {
+           setOBSOLETEBzip2Data(other.getOBSOLETEBzip2Data());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              bitField0_ |= 0x00000001;
+-              raw_ = input.readBytes();
+-              break;
+-            }
+-            case 16: {
+-              bitField0_ |= 0x00000002;
+-              rawSize_ = input.readInt32();
+-              break;
+-            }
+-            case 26: {
+-              bitField0_ |= 0x00000004;
+-              zlibData_ = input.readBytes();
+-              break;
+-            }
+-            case 34: {
+-              bitField0_ |= 0x00000008;
+-              lzmaData_ = input.readBytes();
+-              break;
+-            }
+-            case 42: {
+-              bitField0_ |= 0x00000010;
+-              oBSOLETEBzip2Data_ = input.readBytes();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Fileformat.Blob parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Fileformat.Blob) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // optional bytes raw = 1;
++
+       private com.google.protobuf.ByteString raw_ = com.google.protobuf.ByteString.EMPTY;
++      /**
++       * <code>optional bytes raw = 1;</code>
++       *
++       * <pre>
++       * No compression
++       * </pre>
++       */
+       public boolean hasRaw() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>optional bytes raw = 1;</code>
++       *
++       * <pre>
++       * No compression
++       * </pre>
++       */
+       public com.google.protobuf.ByteString getRaw() {
+         return raw_;
+       }
++      /**
++       * <code>optional bytes raw = 1;</code>
++       *
++       * <pre>
++       * No compression
++       * </pre>
++       */
+       public Builder setRaw(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -420,42 +618,96 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional bytes raw = 1;</code>
++       *
++       * <pre>
++       * No compression
++       * </pre>
++       */
+       public Builder clearRaw() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         raw_ = getDefaultInstance().getRaw();
+         
+         return this;
+       }
+-      
+-      // optional int32 raw_size = 2;
++
+       private int rawSize_ ;
++      /**
++       * <code>optional int32 raw_size = 2;</code>
++       *
++       * <pre>
++       * When compressed, the uncompressed size
++       * </pre>
++       */
+       public boolean hasRawSize() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>optional int32 raw_size = 2;</code>
++       *
++       * <pre>
++       * When compressed, the uncompressed size
++       * </pre>
++       */
+       public int getRawSize() {
+         return rawSize_;
+       }
++      /**
++       * <code>optional int32 raw_size = 2;</code>
++       *
++       * <pre>
++       * When compressed, the uncompressed size
++       * </pre>
++       */
+       public Builder setRawSize(int value) {
+         bitField0_ |= 0x00000002;
+         rawSize_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int32 raw_size = 2;</code>
++       *
++       * <pre>
++       * When compressed, the uncompressed size
++       * </pre>
++       */
+       public Builder clearRawSize() {
+         bitField0_ = (bitField0_ & ~0x00000002);
+         rawSize_ = 0;
+         
+         return this;
+       }
+-      
+-      // optional bytes zlib_data = 3;
++
+       private com.google.protobuf.ByteString zlibData_ = com.google.protobuf.ByteString.EMPTY;
++      /**
++       * <code>optional bytes zlib_data = 3;</code>
++       *
++       * <pre>
++       * Possible compressed versions of the data.
++       * </pre>
++       */
+       public boolean hasZlibData() {
+         return ((bitField0_ & 0x00000004) == 0x00000004);
+       }
++      /**
++       * <code>optional bytes zlib_data = 3;</code>
++       *
++       * <pre>
++       * Possible compressed versions of the data.
++       * </pre>
++       */
+       public com.google.protobuf.ByteString getZlibData() {
+         return zlibData_;
+       }
++      /**
++       * <code>optional bytes zlib_data = 3;</code>
++       *
++       * <pre>
++       * Possible compressed versions of the data.
++       * </pre>
++       */
+       public Builder setZlibData(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -465,21 +717,48 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional bytes zlib_data = 3;</code>
++       *
++       * <pre>
++       * Possible compressed versions of the data.
++       * </pre>
++       */
+       public Builder clearZlibData() {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         zlibData_ = getDefaultInstance().getZlibData();
+         
+         return this;
+       }
+-      
+-      // optional bytes lzma_data = 4;
++
+       private com.google.protobuf.ByteString lzmaData_ = com.google.protobuf.ByteString.EMPTY;
++      /**
++       * <code>optional bytes lzma_data = 4;</code>
++       *
++       * <pre>
++       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++       * </pre>
++       */
+       public boolean hasLzmaData() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional bytes lzma_data = 4;</code>
++       *
++       * <pre>
++       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++       * </pre>
++       */
+       public com.google.protobuf.ByteString getLzmaData() {
+         return lzmaData_;
+       }
++      /**
++       * <code>optional bytes lzma_data = 4;</code>
++       *
++       * <pre>
++       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++       * </pre>
++       */
+       public Builder setLzmaData(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -489,21 +768,48 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional bytes lzma_data = 4;</code>
++       *
++       * <pre>
++       * PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
++       * </pre>
++       */
+       public Builder clearLzmaData() {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         lzmaData_ = getDefaultInstance().getLzmaData();
+         
+         return this;
+       }
+-      
+-      // optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];
++
+       private com.google.protobuf.ByteString oBSOLETEBzip2Data_ = com.google.protobuf.ByteString.EMPTY;
++      /**
++       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++       *
++       * <pre>
++       * Formerly used for bzip2 compressed data. Depreciated in 2010.
++       * </pre>
++       */
+       @java.lang.Deprecated public boolean hasOBSOLETEBzip2Data() {
+         return ((bitField0_ & 0x00000010) == 0x00000010);
+       }
++      /**
++       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++       *
++       * <pre>
++       * Formerly used for bzip2 compressed data. Depreciated in 2010.
++       * </pre>
++       */
+       @java.lang.Deprecated public com.google.protobuf.ByteString getOBSOLETEBzip2Data() {
+         return oBSOLETEBzip2Data_;
+       }
++      /**
++       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++       *
++       * <pre>
++       * Formerly used for bzip2 compressed data. Depreciated in 2010.
++       * </pre>
++       */
+       @java.lang.Deprecated public Builder setOBSOLETEBzip2Data(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -513,110 +819,239 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional bytes OBSOLETE_bzip2_data = 5 [deprecated = true];</code>
++       *
++       * <pre>
++       * Formerly used for bzip2 compressed data. Depreciated in 2010.
++       * </pre>
++       */
+       @java.lang.Deprecated public Builder clearOBSOLETEBzip2Data() {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         oBSOLETEBzip2Data_ = getDefaultInstance().getOBSOLETEBzip2Data();
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.Blob)
+     }
+-    
++
+     static {
+       defaultInstance = new Blob(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.Blob)
+   }
+-  
+-  public interface BlobHeaderOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required string type = 1;
++
++  public interface BlobHeaderOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.BlobHeader)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required string type = 1;</code>
++     */
+     boolean hasType();
+-    String getType();
+-    
+-    // optional bytes indexdata = 2;
++    /**
++     * <code>required string type = 1;</code>
++     */
++    java.lang.String getType();
++    /**
++     * <code>required string type = 1;</code>
++     */
++    com.google.protobuf.ByteString
++        getTypeBytes();
++
++    /**
++     * <code>optional bytes indexdata = 2;</code>
++     */
+     boolean hasIndexdata();
++    /**
++     * <code>optional bytes indexdata = 2;</code>
++     */
+     com.google.protobuf.ByteString getIndexdata();
+-    
+-    // required int32 datasize = 3;
++
++    /**
++     * <code>required int32 datasize = 3;</code>
++     */
+     boolean hasDatasize();
++    /**
++     * <code>required int32 datasize = 3;</code>
++     */
+     int getDatasize();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.BlobHeader}
++   */
+   public static final class BlobHeader extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements BlobHeaderOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.BlobHeader)
++      BlobHeaderOrBuilder {
+     // Use BlobHeader.newBuilder() to construct.
+-    private BlobHeader(Builder builder) {
++    private BlobHeader(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private BlobHeader(boolean noInit) {}
+-    
++    private BlobHeader(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final BlobHeader defaultInstance;
+     public static BlobHeader getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public BlobHeader getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private BlobHeader(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              bitField0_ |= 0x00000001;
++              type_ = bs;
++              break;
++            }
++            case 18: {
++              bitField0_ |= 0x00000002;
++              indexdata_ = input.readBytes();
++              break;
++            }
++            case 24: {
++              bitField0_ |= 0x00000004;
++              datasize_ = input.readInt32();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<BlobHeader> PARSER =
++        new com.google.protobuf.AbstractParser<BlobHeader>() {
++      public BlobHeader parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new BlobHeader(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<BlobHeader> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // required string type = 1;
+     public static final int TYPE_FIELD_NUMBER = 1;
+     private java.lang.Object type_;
++    /**
++     * <code>required string type = 1;</code>
++     */
+     public boolean hasType() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
+-    public String getType() {
++    /**
++     * <code>required string type = 1;</code>
++     */
++    public java.lang.String getType() {
+       java.lang.Object ref = type_;
+-      if (ref instanceof String) {
+-        return (String) ref;
++      if (ref instanceof java.lang.String) {
++        return (java.lang.String) ref;
+       } else {
+         com.google.protobuf.ByteString bs = 
+             (com.google.protobuf.ByteString) ref;
+-        String s = bs.toStringUtf8();
+-        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
++        java.lang.String s = bs.toStringUtf8();
++        if (bs.isValidUtf8()) {
+           type_ = s;
+         }
+         return s;
+       }
+     }
+-    private com.google.protobuf.ByteString getTypeBytes() {
++    /**
++     * <code>required string type = 1;</code>
++     */
++    public com.google.protobuf.ByteString
++        getTypeBytes() {
+       java.lang.Object ref = type_;
+-      if (ref instanceof String) {
++      if (ref instanceof java.lang.String) {
+         com.google.protobuf.ByteString b = 
+-            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
++            com.google.protobuf.ByteString.copyFromUtf8(
++                (java.lang.String) ref);
+         type_ = b;
+         return b;
+       } else {
+         return (com.google.protobuf.ByteString) ref;
+       }
+     }
+-    
+-    // optional bytes indexdata = 2;
++
+     public static final int INDEXDATA_FIELD_NUMBER = 2;
+     private com.google.protobuf.ByteString indexdata_;
++    /**
++     * <code>optional bytes indexdata = 2;</code>
++     */
+     public boolean hasIndexdata() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional bytes indexdata = 2;</code>
++     */
+     public com.google.protobuf.ByteString getIndexdata() {
+       return indexdata_;
+     }
+-    
+-    // required int32 datasize = 3;
++
+     public static final int DATASIZE_FIELD_NUMBER = 3;
+     private int datasize_;
++    /**
++     * <code>required int32 datasize = 3;</code>
++     */
+     public boolean hasDatasize() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>required int32 datasize = 3;</code>
++     */
+     public int getDatasize() {
+       return datasize_;
+     }
+-    
++
+     private void initFields() {
+       type_ = "";
+       indexdata_ = com.google.protobuf.ByteString.EMPTY;
+@@ -625,8 +1060,9 @@ public final class Fileformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasType()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -638,7 +1074,7 @@ public final class Fileformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -651,13 +1087,14 @@ public final class Fileformat {
+       if (((bitField0_ & 0x00000004) == 0x00000004)) {
+         output.writeInt32(3, datasize_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -671,106 +1108,98 @@ public final class Fileformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeInt32Size(3, datasize_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.BlobHeader}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeaderOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.BlobHeader)
++        org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeaderOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         type_ = "";
+@@ -781,15 +1210,15 @@ public final class Fileformat {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader build() {
+         org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -797,17 +1226,7 @@ public final class Fileformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader result = new org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader(this);
+         int from_bitField0_ = bitField0_;
+@@ -827,11 +1246,13 @@ public final class Fileformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader.getDefaultInstance()) return this;
+         if (other.hasType()) {
+-          setType(other.getType());
++          bitField0_ |= 0x00000001;
++          type_ = other.type_;
++          
+         }
+         if (other.hasIndexdata()) {
+           setIndexdata(other.getIndexdata());
+@@ -839,9 +1260,11 @@ public final class Fileformat {
+         if (other.hasDatasize()) {
+           setDatasize(other.getDatasize());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasType()) {
+           
+@@ -853,61 +1276,71 @@ public final class Fileformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              bitField0_ |= 0x00000001;
+-              type_ = input.readBytes();
+-              break;
+-            }
+-            case 18: {
+-              bitField0_ |= 0x00000002;
+-              indexdata_ = input.readBytes();
+-              break;
+-            }
+-            case 24: {
+-              bitField0_ |= 0x00000004;
+-              datasize_ = input.readInt32();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Fileformat.BlobHeader) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required string type = 1;
++
+       private java.lang.Object type_ = "";
++      /**
++       * <code>required string type = 1;</code>
++       */
+       public boolean hasType() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
+-      public String getType() {
++      /**
++       * <code>required string type = 1;</code>
++       */
++      public java.lang.String getType() {
+         java.lang.Object ref = type_;
+-        if (!(ref instanceof String)) {
+-          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
+-          type_ = s;
++        if (!(ref instanceof java.lang.String)) {
++          com.google.protobuf.ByteString bs =
++              (com.google.protobuf.ByteString) ref;
++          java.lang.String s = bs.toStringUtf8();
++          if (bs.isValidUtf8()) {
++            type_ = s;
++          }
+           return s;
+         } else {
+-          return (String) ref;
++          return (java.lang.String) ref;
++        }
++      }
++      /**
++       * <code>required string type = 1;</code>
++       */
++      public com.google.protobuf.ByteString
++          getTypeBytes() {
++        java.lang.Object ref = type_;
++        if (ref instanceof String) {
++          com.google.protobuf.ByteString b = 
++              com.google.protobuf.ByteString.copyFromUtf8(
++                  (java.lang.String) ref);
++          type_ = b;
++          return b;
++        } else {
++          return (com.google.protobuf.ByteString) ref;
+         }
+       }
+-      public Builder setType(String value) {
++      /**
++       * <code>required string type = 1;</code>
++       */
++      public Builder setType(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -916,26 +1349,45 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>required string type = 1;</code>
++       */
+       public Builder clearType() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         type_ = getDefaultInstance().getType();
+         
+         return this;
+       }
+-      void setType(com.google.protobuf.ByteString value) {
+-        bitField0_ |= 0x00000001;
++      /**
++       * <code>required string type = 1;</code>
++       */
++      public Builder setTypeBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  bitField0_ |= 0x00000001;
+         type_ = value;
+         
++        return this;
+       }
+-      
+-      // optional bytes indexdata = 2;
++
+       private com.google.protobuf.ByteString indexdata_ = com.google.protobuf.ByteString.EMPTY;
++      /**
++       * <code>optional bytes indexdata = 2;</code>
++       */
+       public boolean hasIndexdata() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>optional bytes indexdata = 2;</code>
++       */
+       public com.google.protobuf.ByteString getIndexdata() {
+         return indexdata_;
+       }
++      /**
++       * <code>optional bytes indexdata = 2;</code>
++       */
+       public Builder setIndexdata(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -945,48 +1397,62 @@ public final class Fileformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional bytes indexdata = 2;</code>
++       */
+       public Builder clearIndexdata() {
+         bitField0_ = (bitField0_ & ~0x00000002);
+         indexdata_ = getDefaultInstance().getIndexdata();
+         
+         return this;
+       }
+-      
+-      // required int32 datasize = 3;
++
+       private int datasize_ ;
++      /**
++       * <code>required int32 datasize = 3;</code>
++       */
+       public boolean hasDatasize() {
+         return ((bitField0_ & 0x00000004) == 0x00000004);
+       }
++      /**
++       * <code>required int32 datasize = 3;</code>
++       */
+       public int getDatasize() {
+         return datasize_;
+       }
++      /**
++       * <code>required int32 datasize = 3;</code>
++       */
+       public Builder setDatasize(int value) {
+         bitField0_ |= 0x00000004;
+         datasize_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required int32 datasize = 3;</code>
++       */
+       public Builder clearDatasize() {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         datasize_ = 0;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.BlobHeader)
+     }
+-    
++
+     static {
+       defaultInstance = new BlobHeader(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.BlobHeader)
+   }
+-  
+-  
++
++
+   static {
+   }
+-  
++
+   // @@protoc_insertion_point(outer_class_scope)
+ }
+--- a/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Osmformat.java
++++ b/osmosis-osm-binary/gen-src/main/java/org/openstreetmap/osmosis/osmbinary/Osmformat.java
+@@ -8,216 +8,615 @@ public final class Osmformat {
+   public static void registerAllExtensions(
+       com.google.protobuf.ExtensionRegistryLite registry) {
+   }
+-  public interface HeaderBlockOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // optional .OSMPBF.HeaderBBox bbox = 1;
++  public interface HeaderBlockOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.HeaderBlock)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++     */
+     boolean hasBbox();
++    /**
++     * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox();
+-    
+-    // repeated string required_features = 4;
+-    java.util.List<String> getRequiredFeaturesList();
++
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    com.google.protobuf.ProtocolStringList
++        getRequiredFeaturesList();
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
+     int getRequiredFeaturesCount();
+-    String getRequiredFeatures(int index);
+-    
+-    // repeated string optional_features = 5;
+-    java.util.List<String> getOptionalFeaturesList();
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    java.lang.String getRequiredFeatures(int index);
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    com.google.protobuf.ByteString
++        getRequiredFeaturesBytes(int index);
++
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    com.google.protobuf.ProtocolStringList
++        getOptionalFeaturesList();
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
+     int getOptionalFeaturesCount();
+-    String getOptionalFeatures(int index);
+-    
+-    // optional string writingprogram = 16;
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    java.lang.String getOptionalFeatures(int index);
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    com.google.protobuf.ByteString
++        getOptionalFeaturesBytes(int index);
++
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
+     boolean hasWritingprogram();
+-    String getWritingprogram();
+-    
+-    // optional string source = 17;
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
++    java.lang.String getWritingprogram();
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
++    com.google.protobuf.ByteString
++        getWritingprogramBytes();
++
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
+     boolean hasSource();
+-    String getSource();
+-    
+-    // optional int64 osmosis_replication_timestamp = 32;
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
++    java.lang.String getSource();
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
++    com.google.protobuf.ByteString
++        getSourceBytes();
++
++    /**
++     * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++     *
++     * <pre>
++     * replication timestamp, expressed in seconds since the epoch, 
++     * otherwise the same value as in the "timestamp=..." field
++     * in the state.txt file used by Osmosis
++     * </pre>
++     */
+     boolean hasOsmosisReplicationTimestamp();
++    /**
++     * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++     *
++     * <pre>
++     * replication timestamp, expressed in seconds since the epoch, 
++     * otherwise the same value as in the "timestamp=..." field
++     * in the state.txt file used by Osmosis
++     * </pre>
++     */
+     long getOsmosisReplicationTimestamp();
+-    
+-    // optional int64 osmosis_replication_sequence_number = 33;
++
++    /**
++     * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++     *
++     * <pre>
++     * replication sequence number (sequenceNumber in state.txt)
++     * </pre>
++     */
+     boolean hasOsmosisReplicationSequenceNumber();
++    /**
++     * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++     *
++     * <pre>
++     * replication sequence number (sequenceNumber in state.txt)
++     * </pre>
++     */
+     long getOsmosisReplicationSequenceNumber();
+-    
+-    // optional string osmosis_replication_base_url = 34;
++
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
+     boolean hasOsmosisReplicationBaseUrl();
+-    String getOsmosisReplicationBaseUrl();
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
++    java.lang.String getOsmosisReplicationBaseUrl();
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
++    com.google.protobuf.ByteString
++        getOsmosisReplicationBaseUrlBytes();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.HeaderBlock}
++   */
+   public static final class HeaderBlock extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements HeaderBlockOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.HeaderBlock)
++      HeaderBlockOrBuilder {
+     // Use HeaderBlock.newBuilder() to construct.
+-    private HeaderBlock(Builder builder) {
++    private HeaderBlock(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private HeaderBlock(boolean noInit) {}
+-    
++    private HeaderBlock(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final HeaderBlock defaultInstance;
+     public static HeaderBlock getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public HeaderBlock getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private HeaderBlock(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000001) == 0x00000001)) {
++                subBuilder = bbox_.toBuilder();
++              }
++              bbox_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(bbox_);
++                bbox_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000001;
++              break;
++            }
++            case 34: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                requiredFeatures_ = new com.google.protobuf.LazyStringArrayList();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              requiredFeatures_.add(bs);
++              break;
++            }
++            case 42: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                optionalFeatures_ = new com.google.protobuf.LazyStringArrayList();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              optionalFeatures_.add(bs);
++              break;
++            }
++            case 130: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              bitField0_ |= 0x00000002;
++              writingprogram_ = bs;
++              break;
++            }
++            case 138: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              bitField0_ |= 0x00000004;
++              source_ = bs;
++              break;
++            }
++            case 256: {
++              bitField0_ |= 0x00000008;
++              osmosisReplicationTimestamp_ = input.readInt64();
++              break;
++            }
++            case 264: {
++              bitField0_ |= 0x00000010;
++              osmosisReplicationSequenceNumber_ = input.readInt64();
++              break;
++            }
++            case 274: {
++              com.google.protobuf.ByteString bs = input.readBytes();
++              bitField0_ |= 0x00000020;
++              osmosisReplicationBaseUrl_ = bs;
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          requiredFeatures_ = requiredFeatures_.getUnmodifiableView();
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          optionalFeatures_ = optionalFeatures_.getUnmodifiableView();
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<HeaderBlock> PARSER =
++        new com.google.protobuf.AbstractParser<HeaderBlock>() {
++      public HeaderBlock parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new HeaderBlock(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<HeaderBlock> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // optional .OSMPBF.HeaderBBox bbox = 1;
+     public static final int BBOX_FIELD_NUMBER = 1;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox bbox_;
++    /**
++     * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++     */
+     public boolean hasBbox() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox() {
+       return bbox_;
+     }
+-    
+-    // repeated string required_features = 4;
++
+     public static final int REQUIRED_FEATURES_FIELD_NUMBER = 4;
+     private com.google.protobuf.LazyStringList requiredFeatures_;
+-    public java.util.List<String>
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    public com.google.protobuf.ProtocolStringList
+         getRequiredFeaturesList() {
+       return requiredFeatures_;
+     }
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
+     public int getRequiredFeaturesCount() {
+       return requiredFeatures_.size();
+     }
+-    public String getRequiredFeatures(int index) {
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    public java.lang.String getRequiredFeatures(int index) {
+       return requiredFeatures_.get(index);
+     }
+-    
+-    // repeated string optional_features = 5;
++    /**
++     * <code>repeated string required_features = 4;</code>
++     *
++     * <pre>
++     * Additional tags to aid in parsing this dataset 
++     * </pre>
++     */
++    public com.google.protobuf.ByteString
++        getRequiredFeaturesBytes(int index) {
++      return requiredFeatures_.getByteString(index);
++    }
++
+     public static final int OPTIONAL_FEATURES_FIELD_NUMBER = 5;
+     private com.google.protobuf.LazyStringList optionalFeatures_;
+-    public java.util.List<String>
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    public com.google.protobuf.ProtocolStringList
+         getOptionalFeaturesList() {
+       return optionalFeatures_;
+     }
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
+     public int getOptionalFeaturesCount() {
+       return optionalFeatures_.size();
+     }
+-    public String getOptionalFeatures(int index) {
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    public java.lang.String getOptionalFeatures(int index) {
+       return optionalFeatures_.get(index);
+     }
+-    
+-    // optional string writingprogram = 16;
++    /**
++     * <code>repeated string optional_features = 5;</code>
++     */
++    public com.google.protobuf.ByteString
++        getOptionalFeaturesBytes(int index) {
++      return optionalFeatures_.getByteString(index);
++    }
++
+     public static final int WRITINGPROGRAM_FIELD_NUMBER = 16;
+     private java.lang.Object writingprogram_;
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
+     public boolean hasWritingprogram() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
+-    public String getWritingprogram() {
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
++    public java.lang.String getWritingprogram() {
+       java.lang.Object ref = writingprogram_;
+-      if (ref instanceof String) {
+-        return (String) ref;
++      if (ref instanceof java.lang.String) {
++        return (java.lang.String) ref;
+       } else {
+         com.google.protobuf.ByteString bs = 
+             (com.google.protobuf.ByteString) ref;
+-        String s = bs.toStringUtf8();
+-        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
++        java.lang.String s = bs.toStringUtf8();
++        if (bs.isValidUtf8()) {
+           writingprogram_ = s;
+         }
+         return s;
+       }
+     }
+-    private com.google.protobuf.ByteString getWritingprogramBytes() {
++    /**
++     * <code>optional string writingprogram = 16;</code>
++     */
++    public com.google.protobuf.ByteString
++        getWritingprogramBytes() {
+       java.lang.Object ref = writingprogram_;
+-      if (ref instanceof String) {
++      if (ref instanceof java.lang.String) {
+         com.google.protobuf.ByteString b = 
+-            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
++            com.google.protobuf.ByteString.copyFromUtf8(
++                (java.lang.String) ref);
+         writingprogram_ = b;
+         return b;
+       } else {
+         return (com.google.protobuf.ByteString) ref;
+       }
+     }
+-    
+-    // optional string source = 17;
++
+     public static final int SOURCE_FIELD_NUMBER = 17;
+     private java.lang.Object source_;
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
+     public boolean hasSource() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
+-    public String getSource() {
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
++    public java.lang.String getSource() {
+       java.lang.Object ref = source_;
+-      if (ref instanceof String) {
+-        return (String) ref;
++      if (ref instanceof java.lang.String) {
++        return (java.lang.String) ref;
+       } else {
+         com.google.protobuf.ByteString bs = 
+             (com.google.protobuf.ByteString) ref;
+-        String s = bs.toStringUtf8();
+-        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
++        java.lang.String s = bs.toStringUtf8();
++        if (bs.isValidUtf8()) {
+           source_ = s;
+         }
+         return s;
+       }
+     }
+-    private com.google.protobuf.ByteString getSourceBytes() {
++    /**
++     * <code>optional string source = 17;</code>
++     *
++     * <pre>
++     * From the bbox field.
++     * </pre>
++     */
++    public com.google.protobuf.ByteString
++        getSourceBytes() {
+       java.lang.Object ref = source_;
+-      if (ref instanceof String) {
++      if (ref instanceof java.lang.String) {
+         com.google.protobuf.ByteString b = 
+-            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
++            com.google.protobuf.ByteString.copyFromUtf8(
++                (java.lang.String) ref);
+         source_ = b;
+         return b;
+       } else {
+         return (com.google.protobuf.ByteString) ref;
+       }
+     }
+-    
+-    // optional int64 osmosis_replication_timestamp = 32;
++
+     public static final int OSMOSIS_REPLICATION_TIMESTAMP_FIELD_NUMBER = 32;
+     private long osmosisReplicationTimestamp_;
++    /**
++     * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++     *
++     * <pre>
++     * replication timestamp, expressed in seconds since the epoch, 
++     * otherwise the same value as in the "timestamp=..." field
++     * in the state.txt file used by Osmosis
++     * </pre>
++     */
+     public boolean hasOsmosisReplicationTimestamp() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++     *
++     * <pre>
++     * replication timestamp, expressed in seconds since the epoch, 
++     * otherwise the same value as in the "timestamp=..." field
++     * in the state.txt file used by Osmosis
++     * </pre>
++     */
+     public long getOsmosisReplicationTimestamp() {
+       return osmosisReplicationTimestamp_;
+     }
+-    
+-    // optional int64 osmosis_replication_sequence_number = 33;
++
+     public static final int OSMOSIS_REPLICATION_SEQUENCE_NUMBER_FIELD_NUMBER = 33;
+     private long osmosisReplicationSequenceNumber_;
++    /**
++     * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++     *
++     * <pre>
++     * replication sequence number (sequenceNumber in state.txt)
++     * </pre>
++     */
+     public boolean hasOsmosisReplicationSequenceNumber() {
+       return ((bitField0_ & 0x00000010) == 0x00000010);
+     }
++    /**
++     * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++     *
++     * <pre>
++     * replication sequence number (sequenceNumber in state.txt)
++     * </pre>
++     */
+     public long getOsmosisReplicationSequenceNumber() {
+       return osmosisReplicationSequenceNumber_;
+     }
+-    
+-    // optional string osmosis_replication_base_url = 34;
++
+     public static final int OSMOSIS_REPLICATION_BASE_URL_FIELD_NUMBER = 34;
+     private java.lang.Object osmosisReplicationBaseUrl_;
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
+     public boolean hasOsmosisReplicationBaseUrl() {
+       return ((bitField0_ & 0x00000020) == 0x00000020);
+     }
+-    public String getOsmosisReplicationBaseUrl() {
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
++    public java.lang.String getOsmosisReplicationBaseUrl() {
+       java.lang.Object ref = osmosisReplicationBaseUrl_;
+-      if (ref instanceof String) {
+-        return (String) ref;
++      if (ref instanceof java.lang.String) {
++        return (java.lang.String) ref;
+       } else {
+         com.google.protobuf.ByteString bs = 
+             (com.google.protobuf.ByteString) ref;
+-        String s = bs.toStringUtf8();
+-        if (com.google.protobuf.Internal.isValidUtf8(bs)) {
++        java.lang.String s = bs.toStringUtf8();
++        if (bs.isValidUtf8()) {
+           osmosisReplicationBaseUrl_ = s;
+         }
+         return s;
+       }
+     }
+-    private com.google.protobuf.ByteString getOsmosisReplicationBaseUrlBytes() {
++    /**
++     * <code>optional string osmosis_replication_base_url = 34;</code>
++     *
++     * <pre>
++     * replication base URL (from Osmosis' configuration.txt file)
++     * </pre>
++     */
++    public com.google.protobuf.ByteString
++        getOsmosisReplicationBaseUrlBytes() {
+       java.lang.Object ref = osmosisReplicationBaseUrl_;
+-      if (ref instanceof String) {
++      if (ref instanceof java.lang.String) {
+         com.google.protobuf.ByteString b = 
+-            com.google.protobuf.ByteString.copyFromUtf8((String) ref);
++            com.google.protobuf.ByteString.copyFromUtf8(
++                (java.lang.String) ref);
+         osmosisReplicationBaseUrl_ = b;
+         return b;
+       } else {
+         return (com.google.protobuf.ByteString) ref;
+       }
+     }
+-    
++
+     private void initFields() {
+       bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+       requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+@@ -231,8 +630,9 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (hasBbox()) {
+         if (!getBbox().isInitialized()) {
+           memoizedIsInitialized = 0;
+@@ -242,7 +642,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -270,13 +670,14 @@ public final class Osmformat {
+       if (((bitField0_ & 0x00000020) == 0x00000020)) {
+         output.writeBytes(34, getOsmosisReplicationBaseUrlBytes());
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -320,106 +721,98 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeBytesSize(34, getOsmosisReplicationBaseUrlBytes());
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.HeaderBlock}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlockOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.HeaderBlock)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlockOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+@@ -440,15 +833,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000080);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -456,17 +849,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock result = new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock(this);
+         int from_bitField0_ = bitField0_;
+@@ -476,14 +859,12 @@ public final class Osmformat {
+         }
+         result.bbox_ = bbox_;
+         if (((bitField0_ & 0x00000002) == 0x00000002)) {
+-          requiredFeatures_ = new com.google.protobuf.UnmodifiableLazyStringList(
+-              requiredFeatures_);
++          requiredFeatures_ = requiredFeatures_.getUnmodifiableView();
+           bitField0_ = (bitField0_ & ~0x00000002);
+         }
+         result.requiredFeatures_ = requiredFeatures_;
+         if (((bitField0_ & 0x00000004) == 0x00000004)) {
+-          optionalFeatures_ = new com.google.protobuf.UnmodifiableLazyStringList(
+-              optionalFeatures_);
++          optionalFeatures_ = optionalFeatures_.getUnmodifiableView();
+           bitField0_ = (bitField0_ & ~0x00000004);
+         }
+         result.optionalFeatures_ = optionalFeatures_;
+@@ -510,7 +891,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock.getDefaultInstance()) return this;
+         if (other.hasBbox()) {
+@@ -537,10 +918,14 @@ public final class Osmformat {
+           
+         }
+         if (other.hasWritingprogram()) {
+-          setWritingprogram(other.getWritingprogram());
++          bitField0_ |= 0x00000008;
++          writingprogram_ = other.writingprogram_;
++          
+         }
+         if (other.hasSource()) {
+-          setSource(other.getSource());
++          bitField0_ |= 0x00000010;
++          source_ = other.source_;
++          
+         }
+         if (other.hasOsmosisReplicationTimestamp()) {
+           setOsmosisReplicationTimestamp(other.getOsmosisReplicationTimestamp());
+@@ -549,11 +934,15 @@ public final class Osmformat {
+           setOsmosisReplicationSequenceNumber(other.getOsmosisReplicationSequenceNumber());
+         }
+         if (other.hasOsmosisReplicationBaseUrl()) {
+-          setOsmosisReplicationBaseUrl(other.getOsmosisReplicationBaseUrl());
++          bitField0_ |= 0x00000080;
++          osmosisReplicationBaseUrl_ = other.osmosisReplicationBaseUrl_;
++          
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (hasBbox()) {
+           if (!getBbox().isInitialized()) {
+@@ -563,98 +952,64 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.newBuilder();
+-              if (hasBbox()) {
+-                subBuilder.mergeFrom(getBbox());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setBbox(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 34: {
+-              ensureRequiredFeaturesIsMutable();
+-              requiredFeatures_.add(input.readBytes());
+-              break;
+-            }
+-            case 42: {
+-              ensureOptionalFeaturesIsMutable();
+-              optionalFeatures_.add(input.readBytes());
+-              break;
+-            }
+-            case 130: {
+-              bitField0_ |= 0x00000008;
+-              writingprogram_ = input.readBytes();
+-              break;
+-            }
+-            case 138: {
+-              bitField0_ |= 0x00000010;
+-              source_ = input.readBytes();
+-              break;
+-            }
+-            case 256: {
+-              bitField0_ |= 0x00000020;
+-              osmosisReplicationTimestamp_ = input.readInt64();
+-              break;
+-            }
+-            case 264: {
+-              bitField0_ |= 0x00000040;
+-              osmosisReplicationSequenceNumber_ = input.readInt64();
+-              break;
+-            }
+-            case 274: {
+-              bitField0_ |= 0x00000080;
+-              osmosisReplicationBaseUrl_ = input.readBytes();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBlock) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // optional .OSMPBF.HeaderBBox bbox = 1;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public boolean hasBbox() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getBbox() {
+         return bbox_;
+       }
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public Builder setBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         bbox_ = value;
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public Builder setBbox(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.Builder builderForValue) {
+         bbox_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public Builder mergeBbox(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox value) {
+         if (((bitField0_ & 0x00000001) == 0x00000001) &&
+             bbox_ != org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance()) {
+@@ -663,18 +1018,20 @@ public final class Osmformat {
+         } else {
+           bbox_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.HeaderBBox bbox = 1;</code>
++       */
+       public Builder clearBbox() {
+         bbox_ = org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000001);
+         return this;
+       }
+-      
+-      // repeated string required_features = 4;
++
+       private com.google.protobuf.LazyStringList requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+       private void ensureRequiredFeaturesIsMutable() {
+         if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+@@ -682,18 +1039,57 @@ public final class Osmformat {
+           bitField0_ |= 0x00000002;
+          }
+       }
+-      public java.util.List<String>
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
++      public com.google.protobuf.ProtocolStringList
+           getRequiredFeaturesList() {
+-        return java.util.Collections.unmodifiableList(requiredFeatures_);
++        return requiredFeatures_.getUnmodifiableView();
+       }
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
+       public int getRequiredFeaturesCount() {
+         return requiredFeatures_.size();
+       }
+-      public String getRequiredFeatures(int index) {
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
++      public java.lang.String getRequiredFeatures(int index) {
+         return requiredFeatures_.get(index);
+       }
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
++      public com.google.protobuf.ByteString
++          getRequiredFeaturesBytes(int index) {
++        return requiredFeatures_.getByteString(index);
++      }
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
+       public Builder setRequiredFeatures(
+-          int index, String value) {
++          int index, java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -702,7 +1098,15 @@ public final class Osmformat {
+         
+         return this;
+       }
+-      public Builder addRequiredFeatures(String value) {
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
++      public Builder addRequiredFeatures(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -711,26 +1115,52 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
+       public Builder addAllRequiredFeatures(
+-          java.lang.Iterable<String> values) {
++          java.lang.Iterable<java.lang.String> values) {
+         ensureRequiredFeaturesIsMutable();
+-        super.addAll(values, requiredFeatures_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, requiredFeatures_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
+       public Builder clearRequiredFeatures() {
+         requiredFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+         bitField0_ = (bitField0_ & ~0x00000002);
+         
+         return this;
+       }
+-      void addRequiredFeatures(com.google.protobuf.ByteString value) {
+-        ensureRequiredFeaturesIsMutable();
++      /**
++       * <code>repeated string required_features = 4;</code>
++       *
++       * <pre>
++       * Additional tags to aid in parsing this dataset 
++       * </pre>
++       */
++      public Builder addRequiredFeaturesBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  ensureRequiredFeaturesIsMutable();
+         requiredFeatures_.add(value);
+         
++        return this;
+       }
+-      
+-      // repeated string optional_features = 5;
++
+       private com.google.protobuf.LazyStringList optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+       private void ensureOptionalFeaturesIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+@@ -738,18 +1168,37 @@ public final class Osmformat {
+           bitField0_ |= 0x00000004;
+          }
+       }
+-      public java.util.List<String>
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
++      public com.google.protobuf.ProtocolStringList
+           getOptionalFeaturesList() {
+-        return java.util.Collections.unmodifiableList(optionalFeatures_);
++        return optionalFeatures_.getUnmodifiableView();
+       }
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
+       public int getOptionalFeaturesCount() {
+         return optionalFeatures_.size();
+       }
+-      public String getOptionalFeatures(int index) {
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
++      public java.lang.String getOptionalFeatures(int index) {
+         return optionalFeatures_.get(index);
+       }
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
++      public com.google.protobuf.ByteString
++          getOptionalFeaturesBytes(int index) {
++        return optionalFeatures_.getByteString(index);
++      }
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
+       public Builder setOptionalFeatures(
+-          int index, String value) {
++          int index, java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -758,7 +1207,11 @@ public final class Osmformat {
+         
+         return this;
+       }
+-      public Builder addOptionalFeatures(String value) {
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
++      public Builder addOptionalFeatures(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -767,41 +1220,85 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
+       public Builder addAllOptionalFeatures(
+-          java.lang.Iterable<String> values) {
++          java.lang.Iterable<java.lang.String> values) {
+         ensureOptionalFeaturesIsMutable();
+-        super.addAll(values, optionalFeatures_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, optionalFeatures_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
+       public Builder clearOptionalFeatures() {
+         optionalFeatures_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      void addOptionalFeatures(com.google.protobuf.ByteString value) {
+-        ensureOptionalFeaturesIsMutable();
++      /**
++       * <code>repeated string optional_features = 5;</code>
++       */
++      public Builder addOptionalFeaturesBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  ensureOptionalFeaturesIsMutable();
+         optionalFeatures_.add(value);
+         
++        return this;
+       }
+-      
+-      // optional string writingprogram = 16;
++
+       private java.lang.Object writingprogram_ = "";
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
+       public boolean hasWritingprogram() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
+-      public String getWritingprogram() {
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
++      public java.lang.String getWritingprogram() {
+         java.lang.Object ref = writingprogram_;
+-        if (!(ref instanceof String)) {
+-          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
+-          writingprogram_ = s;
++        if (!(ref instanceof java.lang.String)) {
++          com.google.protobuf.ByteString bs =
++              (com.google.protobuf.ByteString) ref;
++          java.lang.String s = bs.toStringUtf8();
++          if (bs.isValidUtf8()) {
++            writingprogram_ = s;
++          }
+           return s;
+         } else {
+-          return (String) ref;
++          return (java.lang.String) ref;
++        }
++      }
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
++      public com.google.protobuf.ByteString
++          getWritingprogramBytes() {
++        java.lang.Object ref = writingprogram_;
++        if (ref instanceof String) {
++          com.google.protobuf.ByteString b = 
++              com.google.protobuf.ByteString.copyFromUtf8(
++                  (java.lang.String) ref);
++          writingprogram_ = b;
++          return b;
++        } else {
++          return (com.google.protobuf.ByteString) ref;
+         }
+       }
+-      public Builder setWritingprogram(String value) {
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
++      public Builder setWritingprogram(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -810,34 +1307,90 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
+       public Builder clearWritingprogram() {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         writingprogram_ = getDefaultInstance().getWritingprogram();
+         
+         return this;
+       }
+-      void setWritingprogram(com.google.protobuf.ByteString value) {
+-        bitField0_ |= 0x00000008;
++      /**
++       * <code>optional string writingprogram = 16;</code>
++       */
++      public Builder setWritingprogramBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  bitField0_ |= 0x00000008;
+         writingprogram_ = value;
+         
++        return this;
+       }
+-      
+-      // optional string source = 17;
++
+       private java.lang.Object source_ = "";
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
+       public boolean hasSource() {
+         return ((bitField0_ & 0x00000010) == 0x00000010);
+       }
+-      public String getSource() {
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
++      public java.lang.String getSource() {
+         java.lang.Object ref = source_;
+-        if (!(ref instanceof String)) {
+-          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
+-          source_ = s;
++        if (!(ref instanceof java.lang.String)) {
++          com.google.protobuf.ByteString bs =
++              (com.google.protobuf.ByteString) ref;
++          java.lang.String s = bs.toStringUtf8();
++          if (bs.isValidUtf8()) {
++            source_ = s;
++          }
+           return s;
+         } else {
+-          return (String) ref;
++          return (java.lang.String) ref;
+         }
+       }
+-      public Builder setSource(String value) {
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
++      public com.google.protobuf.ByteString
++          getSourceBytes() {
++        java.lang.Object ref = source_;
++        if (ref instanceof String) {
++          com.google.protobuf.ByteString b = 
++              com.google.protobuf.ByteString.copyFromUtf8(
++                  (java.lang.String) ref);
++          source_ = b;
++          return b;
++        } else {
++          return (com.google.protobuf.ByteString) ref;
++        }
++      }
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
++      public Builder setSource(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -846,76 +1399,202 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
+       public Builder clearSource() {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         source_ = getDefaultInstance().getSource();
+         
+         return this;
+       }
+-      void setSource(com.google.protobuf.ByteString value) {
+-        bitField0_ |= 0x00000010;
++      /**
++       * <code>optional string source = 17;</code>
++       *
++       * <pre>
++       * From the bbox field.
++       * </pre>
++       */
++      public Builder setSourceBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  bitField0_ |= 0x00000010;
+         source_ = value;
+         
++        return this;
+       }
+-      
+-      // optional int64 osmosis_replication_timestamp = 32;
++
+       private long osmosisReplicationTimestamp_ ;
++      /**
++       * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++       *
++       * <pre>
++       * replication timestamp, expressed in seconds since the epoch, 
++       * otherwise the same value as in the "timestamp=..." field
++       * in the state.txt file used by Osmosis
++       * </pre>
++       */
+       public boolean hasOsmosisReplicationTimestamp() {
+         return ((bitField0_ & 0x00000020) == 0x00000020);
+       }
++      /**
++       * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++       *
++       * <pre>
++       * replication timestamp, expressed in seconds since the epoch, 
++       * otherwise the same value as in the "timestamp=..." field
++       * in the state.txt file used by Osmosis
++       * </pre>
++       */
+       public long getOsmosisReplicationTimestamp() {
+         return osmosisReplicationTimestamp_;
+       }
++      /**
++       * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++       *
++       * <pre>
++       * replication timestamp, expressed in seconds since the epoch, 
++       * otherwise the same value as in the "timestamp=..." field
++       * in the state.txt file used by Osmosis
++       * </pre>
++       */
+       public Builder setOsmosisReplicationTimestamp(long value) {
+         bitField0_ |= 0x00000020;
+         osmosisReplicationTimestamp_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 osmosis_replication_timestamp = 32;</code>
++       *
++       * <pre>
++       * replication timestamp, expressed in seconds since the epoch, 
++       * otherwise the same value as in the "timestamp=..." field
++       * in the state.txt file used by Osmosis
++       * </pre>
++       */
+       public Builder clearOsmosisReplicationTimestamp() {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         osmosisReplicationTimestamp_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional int64 osmosis_replication_sequence_number = 33;
++
+       private long osmosisReplicationSequenceNumber_ ;
++      /**
++       * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++       *
++       * <pre>
++       * replication sequence number (sequenceNumber in state.txt)
++       * </pre>
++       */
+       public boolean hasOsmosisReplicationSequenceNumber() {
+         return ((bitField0_ & 0x00000040) == 0x00000040);
+       }
++      /**
++       * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++       *
++       * <pre>
++       * replication sequence number (sequenceNumber in state.txt)
++       * </pre>
++       */
+       public long getOsmosisReplicationSequenceNumber() {
+         return osmosisReplicationSequenceNumber_;
+       }
++      /**
++       * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++       *
++       * <pre>
++       * replication sequence number (sequenceNumber in state.txt)
++       * </pre>
++       */
+       public Builder setOsmosisReplicationSequenceNumber(long value) {
+         bitField0_ |= 0x00000040;
+         osmosisReplicationSequenceNumber_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 osmosis_replication_sequence_number = 33;</code>
++       *
++       * <pre>
++       * replication sequence number (sequenceNumber in state.txt)
++       * </pre>
++       */
+       public Builder clearOsmosisReplicationSequenceNumber() {
+         bitField0_ = (bitField0_ & ~0x00000040);
+         osmosisReplicationSequenceNumber_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional string osmosis_replication_base_url = 34;
++
+       private java.lang.Object osmosisReplicationBaseUrl_ = "";
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
+       public boolean hasOsmosisReplicationBaseUrl() {
+         return ((bitField0_ & 0x00000080) == 0x00000080);
+       }
+-      public String getOsmosisReplicationBaseUrl() {
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
++      public java.lang.String getOsmosisReplicationBaseUrl() {
+         java.lang.Object ref = osmosisReplicationBaseUrl_;
+-        if (!(ref instanceof String)) {
+-          String s = ((com.google.protobuf.ByteString) ref).toStringUtf8();
+-          osmosisReplicationBaseUrl_ = s;
++        if (!(ref instanceof java.lang.String)) {
++          com.google.protobuf.ByteString bs =
++              (com.google.protobuf.ByteString) ref;
++          java.lang.String s = bs.toStringUtf8();
++          if (bs.isValidUtf8()) {
++            osmosisReplicationBaseUrl_ = s;
++          }
+           return s;
+         } else {
+-          return (String) ref;
++          return (java.lang.String) ref;
++        }
++      }
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
++      public com.google.protobuf.ByteString
++          getOsmosisReplicationBaseUrlBytes() {
++        java.lang.Object ref = osmosisReplicationBaseUrl_;
++        if (ref instanceof String) {
++          com.google.protobuf.ByteString b = 
++              com.google.protobuf.ByteString.copyFromUtf8(
++                  (java.lang.String) ref);
++          osmosisReplicationBaseUrl_ = b;
++          return b;
++        } else {
++          return (com.google.protobuf.ByteString) ref;
+         }
+       }
+-      public Builder setOsmosisReplicationBaseUrl(String value) {
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
++      public Builder setOsmosisReplicationBaseUrl(
++          java.lang.String value) {
+         if (value == null) {
+     throw new NullPointerException();
+   }
+@@ -924,107 +1603,252 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
+       public Builder clearOsmosisReplicationBaseUrl() {
+         bitField0_ = (bitField0_ & ~0x00000080);
+         osmosisReplicationBaseUrl_ = getDefaultInstance().getOsmosisReplicationBaseUrl();
+         
+         return this;
+       }
+-      void setOsmosisReplicationBaseUrl(com.google.protobuf.ByteString value) {
+-        bitField0_ |= 0x00000080;
++      /**
++       * <code>optional string osmosis_replication_base_url = 34;</code>
++       *
++       * <pre>
++       * replication base URL (from Osmosis' configuration.txt file)
++       * </pre>
++       */
++      public Builder setOsmosisReplicationBaseUrlBytes(
++          com.google.protobuf.ByteString value) {
++        if (value == null) {
++    throw new NullPointerException();
++  }
++  bitField0_ |= 0x00000080;
+         osmosisReplicationBaseUrl_ = value;
+         
++        return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.HeaderBlock)
+     }
+-    
++
+     static {
+       defaultInstance = new HeaderBlock(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBlock)
+   }
+-  
+-  public interface HeaderBBoxOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required sint64 left = 1;
++
++  public interface HeaderBBoxOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.HeaderBBox)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required sint64 left = 1;</code>
++     */
+     boolean hasLeft();
++    /**
++     * <code>required sint64 left = 1;</code>
++     */
+     long getLeft();
+-    
+-    // required sint64 right = 2;
++
++    /**
++     * <code>required sint64 right = 2;</code>
++     */
+     boolean hasRight();
++    /**
++     * <code>required sint64 right = 2;</code>
++     */
+     long getRight();
+-    
+-    // required sint64 top = 3;
++
++    /**
++     * <code>required sint64 top = 3;</code>
++     */
+     boolean hasTop();
++    /**
++     * <code>required sint64 top = 3;</code>
++     */
+     long getTop();
+-    
+-    // required sint64 bottom = 4;
++
++    /**
++     * <code>required sint64 bottom = 4;</code>
++     */
+     boolean hasBottom();
++    /**
++     * <code>required sint64 bottom = 4;</code>
++     */
+     long getBottom();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.HeaderBBox}
++   */
+   public static final class HeaderBBox extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements HeaderBBoxOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.HeaderBBox)
++      HeaderBBoxOrBuilder {
+     // Use HeaderBBox.newBuilder() to construct.
+-    private HeaderBBox(Builder builder) {
++    private HeaderBBox(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private HeaderBBox(boolean noInit) {}
+-    
++    private HeaderBBox(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final HeaderBBox defaultInstance;
+     public static HeaderBBox getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public HeaderBBox getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private HeaderBBox(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              left_ = input.readSInt64();
++              break;
++            }
++            case 16: {
++              bitField0_ |= 0x00000002;
++              right_ = input.readSInt64();
++              break;
++            }
++            case 24: {
++              bitField0_ |= 0x00000004;
++              top_ = input.readSInt64();
++              break;
++            }
++            case 32: {
++              bitField0_ |= 0x00000008;
++              bottom_ = input.readSInt64();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<HeaderBBox> PARSER =
++        new com.google.protobuf.AbstractParser<HeaderBBox>() {
++      public HeaderBBox parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new HeaderBBox(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<HeaderBBox> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // required sint64 left = 1;
+     public static final int LEFT_FIELD_NUMBER = 1;
+     private long left_;
++    /**
++     * <code>required sint64 left = 1;</code>
++     */
+     public boolean hasLeft() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>required sint64 left = 1;</code>
++     */
+     public long getLeft() {
+       return left_;
+     }
+-    
+-    // required sint64 right = 2;
++
+     public static final int RIGHT_FIELD_NUMBER = 2;
+     private long right_;
++    /**
++     * <code>required sint64 right = 2;</code>
++     */
+     public boolean hasRight() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>required sint64 right = 2;</code>
++     */
+     public long getRight() {
+       return right_;
+     }
+-    
+-    // required sint64 top = 3;
++
+     public static final int TOP_FIELD_NUMBER = 3;
+     private long top_;
++    /**
++     * <code>required sint64 top = 3;</code>
++     */
+     public boolean hasTop() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>required sint64 top = 3;</code>
++     */
+     public long getTop() {
+       return top_;
+     }
+-    
+-    // required sint64 bottom = 4;
++
+     public static final int BOTTOM_FIELD_NUMBER = 4;
+     private long bottom_;
++    /**
++     * <code>required sint64 bottom = 4;</code>
++     */
+     public boolean hasBottom() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>required sint64 bottom = 4;</code>
++     */
+     public long getBottom() {
+       return bottom_;
+     }
+-    
++
+     private void initFields() {
+       left_ = 0L;
+       right_ = 0L;
+@@ -1034,8 +1858,9 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasLeft()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -1055,7 +1880,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -1071,13 +1896,14 @@ public final class Osmformat {
+       if (((bitField0_ & 0x00000008) == 0x00000008)) {
+         output.writeSInt64(4, bottom_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -1095,106 +1921,98 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeSInt64Size(4, bottom_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.HeaderBBox}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBoxOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.HeaderBBox)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBoxOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         left_ = 0L;
+@@ -1207,15 +2025,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -1223,17 +2041,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox result = new org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox(this);
+         int from_bitField0_ = bitField0_;
+@@ -1257,7 +2065,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox.getDefaultInstance()) return this;
+         if (other.hasLeft()) {
+@@ -1272,9 +2080,11 @@ public final class Osmformat {
+         if (other.hasBottom()) {
+           setBottom(other.getBottom());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasLeft()) {
+           
+@@ -1294,264 +2104,514 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              left_ = input.readSInt64();
+-              break;
+-            }
+-            case 16: {
+-              bitField0_ |= 0x00000002;
+-              right_ = input.readSInt64();
+-              break;
+-            }
+-            case 24: {
+-              bitField0_ |= 0x00000004;
+-              top_ = input.readSInt64();
+-              break;
+-            }
+-            case 32: {
+-              bitField0_ |= 0x00000008;
+-              bottom_ = input.readSInt64();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.HeaderBBox) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required sint64 left = 1;
++
+       private long left_ ;
++      /**
++       * <code>required sint64 left = 1;</code>
++       */
+       public boolean hasLeft() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required sint64 left = 1;</code>
++       */
+       public long getLeft() {
+         return left_;
+       }
++      /**
++       * <code>required sint64 left = 1;</code>
++       */
+       public Builder setLeft(long value) {
+         bitField0_ |= 0x00000001;
+         left_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 left = 1;</code>
++       */
+       public Builder clearLeft() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         left_ = 0L;
+         
+         return this;
+       }
+-      
+-      // required sint64 right = 2;
++
+       private long right_ ;
++      /**
++       * <code>required sint64 right = 2;</code>
++       */
+       public boolean hasRight() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>required sint64 right = 2;</code>
++       */
+       public long getRight() {
+         return right_;
+       }
++      /**
++       * <code>required sint64 right = 2;</code>
++       */
+       public Builder setRight(long value) {
+         bitField0_ |= 0x00000002;
+         right_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 right = 2;</code>
++       */
+       public Builder clearRight() {
+         bitField0_ = (bitField0_ & ~0x00000002);
+         right_ = 0L;
+         
+         return this;
+       }
+-      
+-      // required sint64 top = 3;
++
+       private long top_ ;
++      /**
++       * <code>required sint64 top = 3;</code>
++       */
+       public boolean hasTop() {
+         return ((bitField0_ & 0x00000004) == 0x00000004);
+       }
++      /**
++       * <code>required sint64 top = 3;</code>
++       */
+       public long getTop() {
+         return top_;
+       }
++      /**
++       * <code>required sint64 top = 3;</code>
++       */
+       public Builder setTop(long value) {
+         bitField0_ |= 0x00000004;
+         top_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 top = 3;</code>
++       */
+       public Builder clearTop() {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         top_ = 0L;
+         
+         return this;
+       }
+-      
+-      // required sint64 bottom = 4;
++
+       private long bottom_ ;
++      /**
++       * <code>required sint64 bottom = 4;</code>
++       */
+       public boolean hasBottom() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>required sint64 bottom = 4;</code>
++       */
+       public long getBottom() {
+         return bottom_;
+       }
++      /**
++       * <code>required sint64 bottom = 4;</code>
++       */
+       public Builder setBottom(long value) {
+         bitField0_ |= 0x00000008;
+         bottom_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 bottom = 4;</code>
++       */
+       public Builder clearBottom() {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         bottom_ = 0L;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.HeaderBBox)
+     }
+-    
++
+     static {
+       defaultInstance = new HeaderBBox(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.HeaderBBox)
+   }
+-  
+-  public interface PrimitiveBlockOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required .OSMPBF.StringTable stringtable = 1;
++
++  public interface PrimitiveBlockOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.PrimitiveBlock)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++     */
+     boolean hasStringtable();
++    /**
++     * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable();
+-    
+-    // repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;
++
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> 
+         getPrimitivegroupList();
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getPrimitivegroup(int index);
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     int getPrimitivegroupCount();
+-    
+-    // optional int32 granularity = 17 [default = 100];
++
++    /**
++     * <code>optional int32 granularity = 17 [default = 100];</code>
++     *
++     * <pre>
++     * Granularity, units of nanodegrees, used to store coordinates in this block
++     * </pre>
++     */
+     boolean hasGranularity();
++    /**
++     * <code>optional int32 granularity = 17 [default = 100];</code>
++     *
++     * <pre>
++     * Granularity, units of nanodegrees, used to store coordinates in this block
++     * </pre>
++     */
+     int getGranularity();
+-    
+-    // optional int64 lat_offset = 19 [default = 0];
++
++    /**
++     * <code>optional int64 lat_offset = 19 [default = 0];</code>
++     *
++     * <pre>
++     * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++     * </pre>
++     */
+     boolean hasLatOffset();
++    /**
++     * <code>optional int64 lat_offset = 19 [default = 0];</code>
++     *
++     * <pre>
++     * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++     * </pre>
++     */
+     long getLatOffset();
+-    
+-    // optional int64 lon_offset = 20 [default = 0];
++
++    /**
++     * <code>optional int64 lon_offset = 20 [default = 0];</code>
++     */
+     boolean hasLonOffset();
++    /**
++     * <code>optional int64 lon_offset = 20 [default = 0];</code>
++     */
+     long getLonOffset();
+-    
+-    // optional int32 date_granularity = 18 [default = 1000];
++
++    /**
++     * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++     *
++     * <pre>
++     * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++     * </pre>
++     */
+     boolean hasDateGranularity();
++    /**
++     * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++     *
++     * <pre>
++     * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++     * </pre>
++     */
+     int getDateGranularity();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.PrimitiveBlock}
++   */
+   public static final class PrimitiveBlock extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements PrimitiveBlockOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.PrimitiveBlock)
++      PrimitiveBlockOrBuilder {
+     // Use PrimitiveBlock.newBuilder() to construct.
+-    private PrimitiveBlock(Builder builder) {
++    private PrimitiveBlock(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private PrimitiveBlock(boolean noInit) {}
+-    
++    private PrimitiveBlock(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final PrimitiveBlock defaultInstance;
+     public static PrimitiveBlock getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public PrimitiveBlock getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
+-    private int bitField0_;
+-    // required .OSMPBF.StringTable stringtable = 1;
+-    public static final int STRINGTABLE_FIELD_NUMBER = 1;
+-    private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable stringtable_;
+-    public boolean hasStringtable() {
+-      return ((bitField0_ & 0x00000001) == 0x00000001);
+-    }
+-    public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable() {
+-      return stringtable_;
+-    }
+-    
+-    // repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;
+-    public static final int PRIMITIVEGROUP_FIELD_NUMBER = 2;
+-    private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_;
+-    public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> getPrimitivegroupList() {
+-      return primitivegroup_;
+-    }
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private PrimitiveBlock(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000001) == 0x00000001)) {
++                subBuilder = stringtable_.toBuilder();
++              }
++              stringtable_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(stringtable_);
++                stringtable_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000001;
++              break;
++            }
++            case 18: {
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                primitivegroup_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              primitivegroup_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.PARSER, extensionRegistry));
++              break;
++            }
++            case 136: {
++              bitField0_ |= 0x00000002;
++              granularity_ = input.readInt32();
++              break;
++            }
++            case 144: {
++              bitField0_ |= 0x00000010;
++              dateGranularity_ = input.readInt32();
++              break;
++            }
++            case 152: {
++              bitField0_ |= 0x00000004;
++              latOffset_ = input.readInt64();
++              break;
++            }
++            case 160: {
++              bitField0_ |= 0x00000008;
++              lonOffset_ = input.readInt64();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          primitivegroup_ = java.util.Collections.unmodifiableList(primitivegroup_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<PrimitiveBlock> PARSER =
++        new com.google.protobuf.AbstractParser<PrimitiveBlock>() {
++      public PrimitiveBlock parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new PrimitiveBlock(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<PrimitiveBlock> getParserForType() {
++      return PARSER;
++    }
++
++    private int bitField0_;
++    public static final int STRINGTABLE_FIELD_NUMBER = 1;
++    private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable stringtable_;
++    /**
++     * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++     */
++    public boolean hasStringtable() {
++      return ((bitField0_ & 0x00000001) == 0x00000001);
++    }
++    /**
++     * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++     */
++    public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable() {
++      return stringtable_;
++    }
++
++    public static final int PRIMITIVEGROUP_FIELD_NUMBER = 2;
++    private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_;
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
++    public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> getPrimitivegroupList() {
++      return primitivegroup_;
++    }
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroupOrBuilder> 
+         getPrimitivegroupOrBuilderList() {
+       return primitivegroup_;
+     }
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     public int getPrimitivegroupCount() {
+       return primitivegroup_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getPrimitivegroup(int index) {
+       return primitivegroup_.get(index);
+     }
++    /**
++     * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroupOrBuilder getPrimitivegroupOrBuilder(
+         int index) {
+       return primitivegroup_.get(index);
+     }
+-    
+-    // optional int32 granularity = 17 [default = 100];
++
+     public static final int GRANULARITY_FIELD_NUMBER = 17;
+     private int granularity_;
++    /**
++     * <code>optional int32 granularity = 17 [default = 100];</code>
++     *
++     * <pre>
++     * Granularity, units of nanodegrees, used to store coordinates in this block
++     * </pre>
++     */
+     public boolean hasGranularity() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional int32 granularity = 17 [default = 100];</code>
++     *
++     * <pre>
++     * Granularity, units of nanodegrees, used to store coordinates in this block
++     * </pre>
++     */
+     public int getGranularity() {
+       return granularity_;
+     }
+-    
+-    // optional int64 lat_offset = 19 [default = 0];
++
+     public static final int LAT_OFFSET_FIELD_NUMBER = 19;
+     private long latOffset_;
++    /**
++     * <code>optional int64 lat_offset = 19 [default = 0];</code>
++     *
++     * <pre>
++     * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++     * </pre>
++     */
+     public boolean hasLatOffset() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>optional int64 lat_offset = 19 [default = 0];</code>
++     *
++     * <pre>
++     * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++     * </pre>
++     */
+     public long getLatOffset() {
+       return latOffset_;
+     }
+-    
+-    // optional int64 lon_offset = 20 [default = 0];
++
+     public static final int LON_OFFSET_FIELD_NUMBER = 20;
+     private long lonOffset_;
++    /**
++     * <code>optional int64 lon_offset = 20 [default = 0];</code>
++     */
+     public boolean hasLonOffset() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>optional int64 lon_offset = 20 [default = 0];</code>
++     */
+     public long getLonOffset() {
+       return lonOffset_;
+     }
+-    
+-    // optional int32 date_granularity = 18 [default = 1000];
++
+     public static final int DATE_GRANULARITY_FIELD_NUMBER = 18;
+     private int dateGranularity_;
++    /**
++     * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++     *
++     * <pre>
++     * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++     * </pre>
++     */
+     public boolean hasDateGranularity() {
+       return ((bitField0_ & 0x00000010) == 0x00000010);
+     }
++    /**
++     * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++     *
++     * <pre>
++     * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++     * </pre>
++     */
+     public int getDateGranularity() {
+       return dateGranularity_;
+     }
+-    
++
+     private void initFields() {
+       stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+       primitivegroup_ = java.util.Collections.emptyList();
+@@ -1563,8 +2623,9 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasStringtable()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -1578,7 +2639,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -1600,13 +2661,14 @@ public final class Osmformat {
+       if (((bitField0_ & 0x00000008) == 0x00000008)) {
+         output.writeInt64(20, lonOffset_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -1632,106 +2694,98 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeInt64Size(20, lonOffset_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.PrimitiveBlock}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlockOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.PrimitiveBlock)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlockOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+@@ -1748,15 +2802,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -1764,17 +2818,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock result = new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock(this);
+         int from_bitField0_ = bitField0_;
+@@ -1807,7 +2851,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock.getDefaultInstance()) return this;
+         if (other.hasStringtable()) {
+@@ -1835,9 +2879,11 @@ public final class Osmformat {
+         if (other.hasDateGranularity()) {
+           setDateGranularity(other.getDateGranularity());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasStringtable()) {
+           
+@@ -1851,89 +2897,64 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.newBuilder();
+-              if (hasStringtable()) {
+-                subBuilder.mergeFrom(getStringtable());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setStringtable(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 18: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.newBuilder();
+-              input.readMessage(subBuilder, extensionRegistry);
+-              addPrimitivegroup(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 136: {
+-              bitField0_ |= 0x00000004;
+-              granularity_ = input.readInt32();
+-              break;
+-            }
+-            case 144: {
+-              bitField0_ |= 0x00000020;
+-              dateGranularity_ = input.readInt32();
+-              break;
+-            }
+-            case 152: {
+-              bitField0_ |= 0x00000008;
+-              latOffset_ = input.readInt64();
+-              break;
+-            }
+-            case 160: {
+-              bitField0_ |= 0x00000010;
+-              lonOffset_ = input.readInt64();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveBlock) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required .OSMPBF.StringTable stringtable = 1;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public boolean hasStringtable() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getStringtable() {
+         return stringtable_;
+       }
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public Builder setStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         stringtable_ = value;
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public Builder setStringtable(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.Builder builderForValue) {
+         stringtable_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public Builder mergeStringtable(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable value) {
+         if (((bitField0_ & 0x00000001) == 0x00000001) &&
+             stringtable_ != org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance()) {
+@@ -1942,18 +2963,20 @@ public final class Osmformat {
+         } else {
+           stringtable_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000001;
+         return this;
+       }
++      /**
++       * <code>required .OSMPBF.StringTable stringtable = 1;</code>
++       */
+       public Builder clearStringtable() {
+         stringtable_ = org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000001);
+         return this;
+       }
+-      
+-      // repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> primitivegroup_ =
+         java.util.Collections.emptyList();
+       private void ensurePrimitivegroupIsMutable() {
+@@ -1962,16 +2985,28 @@ public final class Osmformat {
+           bitField0_ |= 0x00000002;
+          }
+       }
+-      
++
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> getPrimitivegroupList() {
+         return java.util.Collections.unmodifiableList(primitivegroup_);
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public int getPrimitivegroupCount() {
+         return primitivegroup_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getPrimitivegroup(int index) {
+         return primitivegroup_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder setPrimitivegroup(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+         if (value == null) {
+@@ -1979,25 +3014,34 @@ public final class Osmformat {
+         }
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.set(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder setPrimitivegroup(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.set(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder addPrimitivegroup(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.add(value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder addPrimitivegroup(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup value) {
+         if (value == null) {
+@@ -2005,282 +3049,615 @@ public final class Osmformat {
+         }
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.add(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder addPrimitivegroup(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.add(builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder addPrimitivegroup(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.Builder builderForValue) {
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.add(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder addAllPrimitivegroup(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup> values) {
+         ensurePrimitivegroupIsMutable();
+-        super.addAll(values, primitivegroup_);
+-        
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, primitivegroup_);
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder clearPrimitivegroup() {
+         primitivegroup_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.PrimitiveGroup primitivegroup = 2;</code>
++       */
+       public Builder removePrimitivegroup(int index) {
+         ensurePrimitivegroupIsMutable();
+         primitivegroup_.remove(index);
+-        
++
+         return this;
+       }
+-      
+-      // optional int32 granularity = 17 [default = 100];
++
+       private int granularity_ = 100;
++      /**
++       * <code>optional int32 granularity = 17 [default = 100];</code>
++       *
++       * <pre>
++       * Granularity, units of nanodegrees, used to store coordinates in this block
++       * </pre>
++       */
+       public boolean hasGranularity() {
+         return ((bitField0_ & 0x00000004) == 0x00000004);
+       }
++      /**
++       * <code>optional int32 granularity = 17 [default = 100];</code>
++       *
++       * <pre>
++       * Granularity, units of nanodegrees, used to store coordinates in this block
++       * </pre>
++       */
+       public int getGranularity() {
+         return granularity_;
+       }
++      /**
++       * <code>optional int32 granularity = 17 [default = 100];</code>
++       *
++       * <pre>
++       * Granularity, units of nanodegrees, used to store coordinates in this block
++       * </pre>
++       */
+       public Builder setGranularity(int value) {
+         bitField0_ |= 0x00000004;
+         granularity_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int32 granularity = 17 [default = 100];</code>
++       *
++       * <pre>
++       * Granularity, units of nanodegrees, used to store coordinates in this block
++       * </pre>
++       */
+       public Builder clearGranularity() {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         granularity_ = 100;
+         
+         return this;
+       }
+-      
+-      // optional int64 lat_offset = 19 [default = 0];
++
+       private long latOffset_ ;
++      /**
++       * <code>optional int64 lat_offset = 19 [default = 0];</code>
++       *
++       * <pre>
++       * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++       * </pre>
++       */
+       public boolean hasLatOffset() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional int64 lat_offset = 19 [default = 0];</code>
++       *
++       * <pre>
++       * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++       * </pre>
++       */
+       public long getLatOffset() {
+         return latOffset_;
+       }
++      /**
++       * <code>optional int64 lat_offset = 19 [default = 0];</code>
++       *
++       * <pre>
++       * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++       * </pre>
++       */
+       public Builder setLatOffset(long value) {
+         bitField0_ |= 0x00000008;
+         latOffset_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 lat_offset = 19 [default = 0];</code>
++       *
++       * <pre>
++       * Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
++       * </pre>
++       */
+       public Builder clearLatOffset() {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         latOffset_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional int64 lon_offset = 20 [default = 0];
++
+       private long lonOffset_ ;
++      /**
++       * <code>optional int64 lon_offset = 20 [default = 0];</code>
++       */
+       public boolean hasLonOffset() {
+         return ((bitField0_ & 0x00000010) == 0x00000010);
+       }
++      /**
++       * <code>optional int64 lon_offset = 20 [default = 0];</code>
++       */
+       public long getLonOffset() {
+         return lonOffset_;
+       }
++      /**
++       * <code>optional int64 lon_offset = 20 [default = 0];</code>
++       */
+       public Builder setLonOffset(long value) {
+         bitField0_ |= 0x00000010;
+         lonOffset_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 lon_offset = 20 [default = 0];</code>
++       */
+       public Builder clearLonOffset() {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         lonOffset_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional int32 date_granularity = 18 [default = 1000];
++
+       private int dateGranularity_ = 1000;
++      /**
++       * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++       *
++       * <pre>
++       * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++       * </pre>
++       */
+       public boolean hasDateGranularity() {
+         return ((bitField0_ & 0x00000020) == 0x00000020);
+       }
++      /**
++       * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++       *
++       * <pre>
++       * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++       * </pre>
++       */
+       public int getDateGranularity() {
+         return dateGranularity_;
+       }
++      /**
++       * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++       *
++       * <pre>
++       * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++       * </pre>
++       */
+       public Builder setDateGranularity(int value) {
+         bitField0_ |= 0x00000020;
+         dateGranularity_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int32 date_granularity = 18 [default = 1000];</code>
++       *
++       * <pre>
++       * Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
++       * </pre>
++       */
+       public Builder clearDateGranularity() {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         dateGranularity_ = 1000;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.PrimitiveBlock)
+     }
+-    
++
+     static {
+       defaultInstance = new PrimitiveBlock(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveBlock)
+   }
+-  
+-  public interface PrimitiveGroupOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // repeated .OSMPBF.Node nodes = 1;
++
++  public interface PrimitiveGroupOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.PrimitiveGroup)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> 
+         getNodesList();
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Node getNodes(int index);
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     int getNodesCount();
+-    
+-    // optional .OSMPBF.DenseNodes dense = 2;
++
++    /**
++     * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++     */
+     boolean hasDense();
++    /**
++     * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDense();
+-    
+-    // repeated .OSMPBF.Way ways = 3;
++
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> 
+         getWaysList();
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Way getWays(int index);
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     int getWaysCount();
+-    
+-    // repeated .OSMPBF.Relation relations = 4;
++
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> 
+         getRelationsList();
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getRelations(int index);
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     int getRelationsCount();
+-    
+-    // repeated .OSMPBF.ChangeSet changesets = 5;
++
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> 
+         getChangesetsList();
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index);
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     int getChangesetsCount();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.PrimitiveGroup}
++   *
++   * <pre>
++   * Group of OSMPrimitives. All primitives in a group must be the same type.
++   * </pre>
++   */
+   public static final class PrimitiveGroup extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements PrimitiveGroupOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.PrimitiveGroup)
++      PrimitiveGroupOrBuilder {
+     // Use PrimitiveGroup.newBuilder() to construct.
+-    private PrimitiveGroup(Builder builder) {
++    private PrimitiveGroup(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private PrimitiveGroup(boolean noInit) {}
+-    
++    private PrimitiveGroup(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final PrimitiveGroup defaultInstance;
+     public static PrimitiveGroup getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public PrimitiveGroup getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private PrimitiveGroup(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++                nodes_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Node>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              nodes_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Node.PARSER, extensionRegistry));
++              break;
++            }
++            case 18: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000001) == 0x00000001)) {
++                subBuilder = dense_.toBuilder();
++              }
++              dense_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(dense_);
++                dense_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000001;
++              break;
++            }
++            case 26: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                ways_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Way>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              ways_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Way.PARSER, extensionRegistry));
++              break;
++            }
++            case 34: {
++              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++                relations_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation>();
++                mutable_bitField0_ |= 0x00000008;
++              }
++              relations_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.PARSER, extensionRegistry));
++              break;
++            }
++            case 42: {
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++                changesets_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              changesets_.add(input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.PARSER, extensionRegistry));
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++          nodes_ = java.util.Collections.unmodifiableList(nodes_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          ways_ = java.util.Collections.unmodifiableList(ways_);
++        }
++        if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++          relations_ = java.util.Collections.unmodifiableList(relations_);
++        }
++        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++          changesets_ = java.util.Collections.unmodifiableList(changesets_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<PrimitiveGroup> PARSER =
++        new com.google.protobuf.AbstractParser<PrimitiveGroup>() {
++      public PrimitiveGroup parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new PrimitiveGroup(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<PrimitiveGroup> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // repeated .OSMPBF.Node nodes = 1;
+     public static final int NODES_FIELD_NUMBER = 1;
+     private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> nodes_;
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> getNodesList() {
+       return nodes_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.NodeOrBuilder> 
+         getNodesOrBuilderList() {
+       return nodes_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     public int getNodesCount() {
+       return nodes_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Node getNodes(int index) {
+       return nodes_.get(index);
+     }
++    /**
++     * <code>repeated .OSMPBF.Node nodes = 1;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.NodeOrBuilder getNodesOrBuilder(
+         int index) {
+       return nodes_.get(index);
+     }
+-    
+-    // optional .OSMPBF.DenseNodes dense = 2;
++
+     public static final int DENSE_FIELD_NUMBER = 2;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes dense_;
++    /**
++     * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++     */
+     public boolean hasDense() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDense() {
+       return dense_;
+     }
+-    
+-    // repeated .OSMPBF.Way ways = 3;
++
+     public static final int WAYS_FIELD_NUMBER = 3;
+     private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> ways_;
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> getWaysList() {
+       return ways_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.WayOrBuilder> 
+         getWaysOrBuilderList() {
+       return ways_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     public int getWaysCount() {
+       return ways_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Way getWays(int index) {
+       return ways_.get(index);
+     }
++    /**
++     * <code>repeated .OSMPBF.Way ways = 3;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.WayOrBuilder getWaysOrBuilder(
+         int index) {
+       return ways_.get(index);
+     }
+-    
+-    // repeated .OSMPBF.Relation relations = 4;
++
+     public static final int RELATIONS_FIELD_NUMBER = 4;
+     private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> relations_;
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> getRelationsList() {
+       return relations_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.RelationOrBuilder> 
+         getRelationsOrBuilderList() {
+       return relations_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     public int getRelationsCount() {
+       return relations_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getRelations(int index) {
+       return relations_.get(index);
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation relations = 4;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.RelationOrBuilder getRelationsOrBuilder(
+         int index) {
+       return relations_.get(index);
+     }
+-    
+-    // repeated .OSMPBF.ChangeSet changesets = 5;
++
+     public static final int CHANGESETS_FIELD_NUMBER = 5;
+     private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> changesets_;
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> getChangesetsList() {
+       return changesets_;
+     }
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     public java.util.List<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder> 
+         getChangesetsOrBuilderList() {
+       return changesets_;
+     }
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     public int getChangesetsCount() {
+       return changesets_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index) {
+       return changesets_.get(index);
+     }
++    /**
++     * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder getChangesetsOrBuilder(
+         int index) {
+       return changesets_.get(index);
+     }
+-    
++
+     private void initFields() {
+       nodes_ = java.util.Collections.emptyList();
+       dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+@@ -2291,8 +3668,9 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       for (int i = 0; i < getNodesCount(); i++) {
+         if (!getNodes(i).isInitialized()) {
+           memoizedIsInitialized = 0;
+@@ -2320,7 +3698,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -2339,13 +3717,14 @@ public final class Osmformat {
+       for (int i = 0; i < changesets_.size(); i++) {
+         output.writeMessage(5, changesets_.get(i));
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       for (int i = 0; i < nodes_.size(); i++) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -2367,106 +3746,102 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeMessageSize(5, changesets_.get(i));
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.PrimitiveGroup}
++     *
++     * <pre>
++     * Group of OSMPrimitives. All primitives in a group must be the same type.
++     * </pre>
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroupOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.PrimitiveGroup)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroupOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         nodes_ = java.util.Collections.emptyList();
+@@ -2481,15 +3856,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -2497,17 +3872,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup result = new org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup(this);
+         int from_bitField0_ = bitField0_;
+@@ -2539,7 +3904,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup.getDefaultInstance()) return this;
+         if (!other.nodes_.isEmpty()) {
+@@ -2585,9 +3950,11 @@ public final class Osmformat {
+           }
+           
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         for (int i = 0; i < getNodesCount(); i++) {
+           if (!getNodes(i).isInitialized()) {
+@@ -2615,64 +3982,26 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Node.newBuilder();
+-              input.readMessage(subBuilder, extensionRegistry);
+-              addNodes(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 18: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.newBuilder();
+-              if (hasDense()) {
+-                subBuilder.mergeFrom(getDense());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setDense(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 26: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Way.newBuilder();
+-              input.readMessage(subBuilder, extensionRegistry);
+-              addWays(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 34: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.newBuilder();
+-              input.readMessage(subBuilder, extensionRegistry);
+-              addRelations(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 42: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.newBuilder();
+-              input.readMessage(subBuilder, extensionRegistry);
+-              addChangesets(subBuilder.buildPartial());
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.PrimitiveGroup) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // repeated .OSMPBF.Node nodes = 1;
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> nodes_ =
+         java.util.Collections.emptyList();
+       private void ensureNodesIsMutable() {
+@@ -2681,16 +4010,28 @@ public final class Osmformat {
+           bitField0_ |= 0x00000001;
+          }
+       }
+-      
++
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Node> getNodesList() {
+         return java.util.Collections.unmodifiableList(nodes_);
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public int getNodesCount() {
+         return nodes_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Node getNodes(int index) {
+         return nodes_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder setNodes(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+         if (value == null) {
+@@ -2698,25 +4039,34 @@ public final class Osmformat {
+         }
+         ensureNodesIsMutable();
+         nodes_.set(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder setNodes(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+         ensureNodesIsMutable();
+         nodes_.set(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder addNodes(org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         ensureNodesIsMutable();
+         nodes_.add(value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder addNodes(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node value) {
+         if (value == null) {
+@@ -2724,67 +4074,97 @@ public final class Osmformat {
+         }
+         ensureNodesIsMutable();
+         nodes_.add(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder addNodes(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+         ensureNodesIsMutable();
+         nodes_.add(builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder addNodes(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Node.Builder builderForValue) {
+         ensureNodesIsMutable();
+         nodes_.add(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder addAllNodes(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Node> values) {
+         ensureNodesIsMutable();
+-        super.addAll(values, nodes_);
+-        
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, nodes_);
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder clearNodes() {
+         nodes_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Node nodes = 1;</code>
++       */
+       public Builder removeNodes(int index) {
+         ensureNodesIsMutable();
+         nodes_.remove(index);
+-        
++
+         return this;
+       }
+-      
+-      // optional .OSMPBF.DenseNodes dense = 2;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public boolean hasDense() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDense() {
+         return dense_;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public Builder setDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         dense_ = value;
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public Builder setDense(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.Builder builderForValue) {
+         dense_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public Builder mergeDense(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes value) {
+         if (((bitField0_ & 0x00000002) == 0x00000002) &&
+             dense_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance()) {
+@@ -2793,18 +4173,20 @@ public final class Osmformat {
+         } else {
+           dense_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseNodes dense = 2;</code>
++       */
+       public Builder clearDense() {
+         dense_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000002);
+         return this;
+       }
+-      
+-      // repeated .OSMPBF.Way ways = 3;
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> ways_ =
+         java.util.Collections.emptyList();
+       private void ensureWaysIsMutable() {
+@@ -2813,16 +4195,28 @@ public final class Osmformat {
+           bitField0_ |= 0x00000004;
+          }
+       }
+-      
++
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Way> getWaysList() {
+         return java.util.Collections.unmodifiableList(ways_);
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public int getWaysCount() {
+         return ways_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Way getWays(int index) {
+         return ways_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder setWays(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+         if (value == null) {
+@@ -2830,25 +4224,34 @@ public final class Osmformat {
+         }
+         ensureWaysIsMutable();
+         ways_.set(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder setWays(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+         ensureWaysIsMutable();
+         ways_.set(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder addWays(org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         ensureWaysIsMutable();
+         ways_.add(value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder addWays(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way value) {
+         if (value == null) {
+@@ -2856,44 +4259,59 @@ public final class Osmformat {
+         }
+         ensureWaysIsMutable();
+         ways_.add(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder addWays(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+         ensureWaysIsMutable();
+         ways_.add(builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder addWays(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Way.Builder builderForValue) {
+         ensureWaysIsMutable();
+         ways_.add(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder addAllWays(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Way> values) {
+         ensureWaysIsMutable();
+-        super.addAll(values, ways_);
+-        
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, ways_);
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder clearWays() {
+         ways_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Way ways = 3;</code>
++       */
+       public Builder removeWays(int index) {
+         ensureWaysIsMutable();
+         ways_.remove(index);
+-        
++
+         return this;
+       }
+-      
+-      // repeated .OSMPBF.Relation relations = 4;
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> relations_ =
+         java.util.Collections.emptyList();
+       private void ensureRelationsIsMutable() {
+@@ -2902,16 +4320,28 @@ public final class Osmformat {
+           bitField0_ |= 0x00000008;
+          }
+       }
+-      
++
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> getRelationsList() {
+         return java.util.Collections.unmodifiableList(relations_);
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public int getRelationsCount() {
+         return relations_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getRelations(int index) {
+         return relations_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder setRelations(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+         if (value == null) {
+@@ -2919,25 +4349,34 @@ public final class Osmformat {
+         }
+         ensureRelationsIsMutable();
+         relations_.set(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder setRelations(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+         ensureRelationsIsMutable();
+         relations_.set(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder addRelations(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         ensureRelationsIsMutable();
+         relations_.add(value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder addRelations(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation value) {
+         if (value == null) {
+@@ -2945,44 +4384,59 @@ public final class Osmformat {
+         }
+         ensureRelationsIsMutable();
+         relations_.add(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder addRelations(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+         ensureRelationsIsMutable();
+         relations_.add(builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder addRelations(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.Builder builderForValue) {
+         ensureRelationsIsMutable();
+         relations_.add(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder addAllRelations(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation> values) {
+         ensureRelationsIsMutable();
+-        super.addAll(values, relations_);
+-        
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, relations_);
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder clearRelations() {
+         relations_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000008);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation relations = 4;</code>
++       */
+       public Builder removeRelations(int index) {
+         ensureRelationsIsMutable();
+         relations_.remove(index);
+-        
++
+         return this;
+       }
+-      
+-      // repeated .OSMPBF.ChangeSet changesets = 5;
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> changesets_ =
+         java.util.Collections.emptyList();
+       private void ensureChangesetsIsMutable() {
+@@ -2991,16 +4445,28 @@ public final class Osmformat {
+           bitField0_ |= 0x00000010;
+          }
+       }
+-      
++
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> getChangesetsList() {
+         return java.util.Collections.unmodifiableList(changesets_);
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public int getChangesetsCount() {
+         return changesets_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getChangesets(int index) {
+         return changesets_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder setChangesets(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+         if (value == null) {
+@@ -3008,25 +4474,34 @@ public final class Osmformat {
+         }
+         ensureChangesetsIsMutable();
+         changesets_.set(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder setChangesets(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+         ensureChangesetsIsMutable();
+         changesets_.set(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder addChangesets(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         ensureChangesetsIsMutable();
+         changesets_.add(value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder addChangesets(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet value) {
+         if (value == null) {
+@@ -3034,119 +4509,236 @@ public final class Osmformat {
+         }
+         ensureChangesetsIsMutable();
+         changesets_.add(index, value);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder addChangesets(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+         ensureChangesetsIsMutable();
+         changesets_.add(builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder addChangesets(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.Builder builderForValue) {
+         ensureChangesetsIsMutable();
+         changesets_.add(index, builderForValue.build());
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder addAllChangesets(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet> values) {
+         ensureChangesetsIsMutable();
+-        super.addAll(values, changesets_);
+-        
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, changesets_);
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder clearChangesets() {
+         changesets_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+-        
++
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.ChangeSet changesets = 5;</code>
++       */
+       public Builder removeChangesets(int index) {
+         ensureChangesetsIsMutable();
+         changesets_.remove(index);
+-        
++
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.PrimitiveGroup)
+     }
+-    
++
+     static {
+       defaultInstance = new PrimitiveGroup(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.PrimitiveGroup)
+   }
+-  
+-  public interface StringTableOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // repeated bytes s = 1;
++
++  public interface StringTableOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.StringTable)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
+     java.util.List<com.google.protobuf.ByteString> getSList();
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
+     int getSCount();
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
+     com.google.protobuf.ByteString getS(int index);
+   }
++  /**
++   * Protobuf type {@code OSMPBF.StringTable}
++   *
++   * <pre>
++   ** String table, contains the common strings in each block.
++   *Note that we reserve index '0' as a delimiter, so the entry at that
++   *index in the table is ALWAYS blank and unused.
++   * </pre>
++   */
+   public static final class StringTable extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements StringTableOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.StringTable)
++      StringTableOrBuilder {
+     // Use StringTable.newBuilder() to construct.
+-    private StringTable(Builder builder) {
++    private StringTable(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private StringTable(boolean noInit) {}
+-    
++    private StringTable(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final StringTable defaultInstance;
+     public static StringTable getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public StringTable getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
+-    // repeated bytes s = 1;
+-    public static final int S_FIELD_NUMBER = 1;
+-    private java.util.List<com.google.protobuf.ByteString> s_;
+-    public java.util.List<com.google.protobuf.ByteString>
+-        getSList() {
+-      return s_;
+-    }
+-    public int getSCount() {
+-      return s_.size();
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private StringTable(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 10: {
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++                s_ = new java.util.ArrayList<com.google.protobuf.ByteString>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              s_.add(input.readBytes());
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++          s_ = java.util.Collections.unmodifiableList(s_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<StringTable> PARSER =
++        new com.google.protobuf.AbstractParser<StringTable>() {
++      public StringTable parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new StringTable(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<StringTable> getParserForType() {
++      return PARSER;
++    }
++
++    public static final int S_FIELD_NUMBER = 1;
++    private java.util.List<com.google.protobuf.ByteString> s_;
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
++    public java.util.List<com.google.protobuf.ByteString>
++        getSList() {
++      return s_;
++    }
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
++    public int getSCount() {
++      return s_.size();
+     }
++    /**
++     * <code>repeated bytes s = 1;</code>
++     */
+     public com.google.protobuf.ByteString getS(int index) {
+       return s_.get(index);
+     }
+-    
++
+     private void initFields() {
+-      s_ = java.util.Collections.emptyList();;
++      s_ = java.util.Collections.emptyList();
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+       for (int i = 0; i < s_.size(); i++) {
+         output.writeBytes(1, s_.get(i));
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       {
+         int dataSize = 0;
+@@ -3157,121 +4749,119 @@ public final class Osmformat {
+         size += dataSize;
+         size += 1 * getSList().size();
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.StringTable}
++     *
++     * <pre>
++     ** String table, contains the common strings in each block.
++     *Note that we reserve index '0' as a delimiter, so the entry at that
++     *index in the table is ALWAYS blank and unused.
++     * </pre>
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.StringTableOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.StringTable)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.StringTableOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+-        s_ = java.util.Collections.emptyList();;
++        s_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -3279,17 +4869,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable result = new org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable(this);
+         int from_bitField0_ = bitField0_;
+@@ -3300,7 +4880,7 @@ public final class Osmformat {
+         result.s_ = s_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable.getDefaultInstance()) return this;
+         if (!other.s_.isEmpty()) {
+@@ -3313,59 +4893,63 @@ public final class Osmformat {
+           }
+           
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 10: {
+-              ensureSIsMutable();
+-              s_.add(input.readBytes());
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.StringTable) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // repeated bytes s = 1;
+-      private java.util.List<com.google.protobuf.ByteString> s_ = java.util.Collections.emptyList();;
++
++      private java.util.List<com.google.protobuf.ByteString> s_ = java.util.Collections.emptyList();
+       private void ensureSIsMutable() {
+         if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+           s_ = new java.util.ArrayList<com.google.protobuf.ByteString>(s_);
+           bitField0_ |= 0x00000001;
+          }
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public java.util.List<com.google.protobuf.ByteString>
+           getSList() {
+         return java.util.Collections.unmodifiableList(s_);
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public int getSCount() {
+         return s_.size();
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public com.google.protobuf.ByteString getS(int index) {
+         return s_.get(index);
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public Builder setS(
+           int index, com.google.protobuf.ByteString value) {
+         if (value == null) {
+@@ -3376,6 +4960,9 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public Builder addS(com.google.protobuf.ByteString value) {
+         if (value == null) {
+     throw new NullPointerException();
+@@ -3385,137 +4972,364 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public Builder addAllS(
+           java.lang.Iterable<? extends com.google.protobuf.ByteString> values) {
+         ensureSIsMutable();
+-        super.addAll(values, s_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, s_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated bytes s = 1;</code>
++       */
+       public Builder clearS() {
+-        s_ = java.util.Collections.emptyList();;
++        s_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.StringTable)
+     }
+-    
++
+     static {
+       defaultInstance = new StringTable(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.StringTable)
+   }
+-  
+-  public interface InfoOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // optional int32 version = 1 [default = -1];
++
++  public interface InfoOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.Info)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>optional int32 version = 1 [default = -1];</code>
++     */
+     boolean hasVersion();
++    /**
++     * <code>optional int32 version = 1 [default = -1];</code>
++     */
+     int getVersion();
+-    
+-    // optional int64 timestamp = 2;
++
++    /**
++     * <code>optional int64 timestamp = 2;</code>
++     */
+     boolean hasTimestamp();
++    /**
++     * <code>optional int64 timestamp = 2;</code>
++     */
+     long getTimestamp();
+-    
+-    // optional int64 changeset = 3;
++
++    /**
++     * <code>optional int64 changeset = 3;</code>
++     */
+     boolean hasChangeset();
++    /**
++     * <code>optional int64 changeset = 3;</code>
++     */
+     long getChangeset();
+-    
+-    // optional int32 uid = 4;
++
++    /**
++     * <code>optional int32 uid = 4;</code>
++     */
+     boolean hasUid();
++    /**
++     * <code>optional int32 uid = 4;</code>
++     */
+     int getUid();
+-    
+-    // optional uint32 user_sid = 5;
++
++    /**
++     * <code>optional uint32 user_sid = 5;</code>
++     *
++     * <pre>
++     * String IDs
++     * </pre>
++     */
+     boolean hasUserSid();
++    /**
++     * <code>optional uint32 user_sid = 5;</code>
++     *
++     * <pre>
++     * String IDs
++     * </pre>
++     */
+     int getUserSid();
+-    
+-    // optional bool visible = 6;
++
++    /**
++     * <code>optional bool visible = 6;</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     boolean hasVisible();
++    /**
++     * <code>optional bool visible = 6;</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     boolean getVisible();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.Info}
++   *
++   * <pre>
++   * Optional metadata that may be included into each primitive. 
++   * </pre>
++   */
+   public static final class Info extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements InfoOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.Info)
++      InfoOrBuilder {
+     // Use Info.newBuilder() to construct.
+-    private Info(Builder builder) {
++    private Info(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private Info(boolean noInit) {}
+-    
++    private Info(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final Info defaultInstance;
+     public static Info getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public Info getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private Info(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              version_ = input.readInt32();
++              break;
++            }
++            case 16: {
++              bitField0_ |= 0x00000002;
++              timestamp_ = input.readInt64();
++              break;
++            }
++            case 24: {
++              bitField0_ |= 0x00000004;
++              changeset_ = input.readInt64();
++              break;
++            }
++            case 32: {
++              bitField0_ |= 0x00000008;
++              uid_ = input.readInt32();
++              break;
++            }
++            case 40: {
++              bitField0_ |= 0x00000010;
++              userSid_ = input.readUInt32();
++              break;
++            }
++            case 48: {
++              bitField0_ |= 0x00000020;
++              visible_ = input.readBool();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<Info> PARSER =
++        new com.google.protobuf.AbstractParser<Info>() {
++      public Info parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new Info(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<Info> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // optional int32 version = 1 [default = -1];
+     public static final int VERSION_FIELD_NUMBER = 1;
+     private int version_;
++    /**
++     * <code>optional int32 version = 1 [default = -1];</code>
++     */
+     public boolean hasVersion() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>optional int32 version = 1 [default = -1];</code>
++     */
+     public int getVersion() {
+       return version_;
+     }
+-    
+-    // optional int64 timestamp = 2;
++
+     public static final int TIMESTAMP_FIELD_NUMBER = 2;
+     private long timestamp_;
++    /**
++     * <code>optional int64 timestamp = 2;</code>
++     */
+     public boolean hasTimestamp() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional int64 timestamp = 2;</code>
++     */
+     public long getTimestamp() {
+       return timestamp_;
+     }
+-    
+-    // optional int64 changeset = 3;
++
+     public static final int CHANGESET_FIELD_NUMBER = 3;
+     private long changeset_;
++    /**
++     * <code>optional int64 changeset = 3;</code>
++     */
+     public boolean hasChangeset() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>optional int64 changeset = 3;</code>
++     */
+     public long getChangeset() {
+       return changeset_;
+     }
+-    
+-    // optional int32 uid = 4;
++
+     public static final int UID_FIELD_NUMBER = 4;
+     private int uid_;
++    /**
++     * <code>optional int32 uid = 4;</code>
++     */
+     public boolean hasUid() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>optional int32 uid = 4;</code>
++     */
+     public int getUid() {
+       return uid_;
+     }
+-    
+-    // optional uint32 user_sid = 5;
++
+     public static final int USER_SID_FIELD_NUMBER = 5;
+     private int userSid_;
++    /**
++     * <code>optional uint32 user_sid = 5;</code>
++     *
++     * <pre>
++     * String IDs
++     * </pre>
++     */
+     public boolean hasUserSid() {
+       return ((bitField0_ & 0x00000010) == 0x00000010);
+     }
++    /**
++     * <code>optional uint32 user_sid = 5;</code>
++     *
++     * <pre>
++     * String IDs
++     * </pre>
++     */
+     public int getUserSid() {
+       return userSid_;
+     }
+-    
+-    // optional bool visible = 6;
++
+     public static final int VISIBLE_FIELD_NUMBER = 6;
+     private boolean visible_;
++    /**
++     * <code>optional bool visible = 6;</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     public boolean hasVisible() {
+       return ((bitField0_ & 0x00000020) == 0x00000020);
+     }
++    /**
++     * <code>optional bool visible = 6;</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     public boolean getVisible() {
+       return visible_;
+     }
+-    
++
+     private void initFields() {
+       version_ = -1;
+       timestamp_ = 0L;
+@@ -3527,12 +5341,13 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -3554,13 +5369,14 @@ public final class Osmformat {
+       if (((bitField0_ & 0x00000020) == 0x00000020)) {
+         output.writeBool(6, visible_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -3586,106 +5402,102 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeBoolSize(6, visible_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Info parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Info prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.Info}
++     *
++     * <pre>
++     * Optional metadata that may be included into each primitive. 
++     * </pre>
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Info, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.InfoOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.Info)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.InfoOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         version_ = -1;
+@@ -3702,15 +5514,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Info result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -3718,17 +5530,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.Info buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.Info result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Info result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Info(this);
+         int from_bitField0_ = bitField0_;
+@@ -3760,7 +5562,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Info other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) return this;
+         if (other.hasVersion()) {
+@@ -3781,361 +5583,928 @@ public final class Osmformat {
+         if (other.hasVisible()) {
+           setVisible(other.getVisible());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              version_ = input.readInt32();
+-              break;
+-            }
+-            case 16: {
+-              bitField0_ |= 0x00000002;
+-              timestamp_ = input.readInt64();
+-              break;
+-            }
+-            case 24: {
+-              bitField0_ |= 0x00000004;
+-              changeset_ = input.readInt64();
+-              break;
+-            }
+-            case 32: {
+-              bitField0_ |= 0x00000008;
+-              uid_ = input.readInt32();
+-              break;
+-            }
+-            case 40: {
+-              bitField0_ |= 0x00000010;
+-              userSid_ = input.readUInt32();
+-              break;
+-            }
+-            case 48: {
+-              bitField0_ |= 0x00000020;
+-              visible_ = input.readBool();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.Info parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Info) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // optional int32 version = 1 [default = -1];
++
+       private int version_ = -1;
++      /**
++       * <code>optional int32 version = 1 [default = -1];</code>
++       */
+       public boolean hasVersion() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>optional int32 version = 1 [default = -1];</code>
++       */
+       public int getVersion() {
+         return version_;
+       }
++      /**
++       * <code>optional int32 version = 1 [default = -1];</code>
++       */
+       public Builder setVersion(int value) {
+         bitField0_ |= 0x00000001;
+         version_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int32 version = 1 [default = -1];</code>
++       */
+       public Builder clearVersion() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         version_ = -1;
+         
+         return this;
+       }
+-      
+-      // optional int64 timestamp = 2;
++
+       private long timestamp_ ;
++      /**
++       * <code>optional int64 timestamp = 2;</code>
++       */
+       public boolean hasTimestamp() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>optional int64 timestamp = 2;</code>
++       */
+       public long getTimestamp() {
+         return timestamp_;
+       }
++      /**
++       * <code>optional int64 timestamp = 2;</code>
++       */
+       public Builder setTimestamp(long value) {
+         bitField0_ |= 0x00000002;
+         timestamp_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 timestamp = 2;</code>
++       */
+       public Builder clearTimestamp() {
+         bitField0_ = (bitField0_ & ~0x00000002);
+         timestamp_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional int64 changeset = 3;
++
+       private long changeset_ ;
++      /**
++       * <code>optional int64 changeset = 3;</code>
++       */
+       public boolean hasChangeset() {
+         return ((bitField0_ & 0x00000004) == 0x00000004);
+       }
++      /**
++       * <code>optional int64 changeset = 3;</code>
++       */
+       public long getChangeset() {
+         return changeset_;
+       }
++      /**
++       * <code>optional int64 changeset = 3;</code>
++       */
+       public Builder setChangeset(long value) {
+         bitField0_ |= 0x00000004;
+         changeset_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int64 changeset = 3;</code>
++       */
+       public Builder clearChangeset() {
+         bitField0_ = (bitField0_ & ~0x00000004);
+         changeset_ = 0L;
+         
+         return this;
+       }
+-      
+-      // optional int32 uid = 4;
++
+       private int uid_ ;
++      /**
++       * <code>optional int32 uid = 4;</code>
++       */
+       public boolean hasUid() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional int32 uid = 4;</code>
++       */
+       public int getUid() {
+         return uid_;
+       }
++      /**
++       * <code>optional int32 uid = 4;</code>
++       */
+       public Builder setUid(int value) {
+         bitField0_ |= 0x00000008;
+         uid_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional int32 uid = 4;</code>
++       */
+       public Builder clearUid() {
+         bitField0_ = (bitField0_ & ~0x00000008);
+         uid_ = 0;
+         
+         return this;
+       }
+-      
+-      // optional uint32 user_sid = 5;
++
+       private int userSid_ ;
++      /**
++       * <code>optional uint32 user_sid = 5;</code>
++       *
++       * <pre>
++       * String IDs
++       * </pre>
++       */
+       public boolean hasUserSid() {
+         return ((bitField0_ & 0x00000010) == 0x00000010);
+       }
++      /**
++       * <code>optional uint32 user_sid = 5;</code>
++       *
++       * <pre>
++       * String IDs
++       * </pre>
++       */
+       public int getUserSid() {
+         return userSid_;
+       }
++      /**
++       * <code>optional uint32 user_sid = 5;</code>
++       *
++       * <pre>
++       * String IDs
++       * </pre>
++       */
+       public Builder setUserSid(int value) {
+         bitField0_ |= 0x00000010;
+         userSid_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional uint32 user_sid = 5;</code>
++       *
++       * <pre>
++       * String IDs
++       * </pre>
++       */
+       public Builder clearUserSid() {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         userSid_ = 0;
+         
+         return this;
+       }
+-      
+-      // optional bool visible = 6;
++
+       private boolean visible_ ;
++      /**
++       * <code>optional bool visible = 6;</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public boolean hasVisible() {
+         return ((bitField0_ & 0x00000020) == 0x00000020);
+       }
++      /**
++       * <code>optional bool visible = 6;</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public boolean getVisible() {
+         return visible_;
+       }
++      /**
++       * <code>optional bool visible = 6;</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder setVisible(boolean value) {
+         bitField0_ |= 0x00000020;
+         visible_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>optional bool visible = 6;</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder clearVisible() {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         visible_ = false;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.Info)
+     }
+-    
++
+     static {
+       defaultInstance = new Info(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.Info)
+   }
+-  
+-  public interface DenseInfoOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // repeated int32 version = 1 [packed = true];
++
++  public interface DenseInfoOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.DenseInfo)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     java.util.List<java.lang.Integer> getVersionList();
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     int getVersionCount();
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     int getVersion(int index);
+-    
+-    // repeated sint64 timestamp = 2 [packed = true];
++
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getTimestampList();
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getTimestampCount();
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getTimestamp(int index);
+-    
+-    // repeated sint64 changeset = 3 [packed = true];
++
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getChangesetList();
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getChangesetCount();
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getChangeset(int index);
+-    
+-    // repeated sint32 uid = 4 [packed = true];
++
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getUidList();
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getUidCount();
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getUid(int index);
+-    
+-    // repeated sint32 user_sid = 5 [packed = true];
++
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getUserSidList();
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     int getUserSidCount();
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     int getUserSid(int index);
+-    
+-    // repeated bool visible = 6 [packed = true];
++
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     java.util.List<java.lang.Boolean> getVisibleList();
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     int getVisibleCount();
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     boolean getVisible(int index);
+   }
++  /**
++   * Protobuf type {@code OSMPBF.DenseInfo}
++   *
++   * <pre>
++   ** Optional metadata that may be included into each primitive. Special dense format used in DenseNodes. 
++   * </pre>
++   */
+   public static final class DenseInfo extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements DenseInfoOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.DenseInfo)
++      DenseInfoOrBuilder {
+     // Use DenseInfo.newBuilder() to construct.
+-    private DenseInfo(Builder builder) {
++    private DenseInfo(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private DenseInfo(boolean noInit) {}
+-    
++    private DenseInfo(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final DenseInfo defaultInstance;
+     public static DenseInfo getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public DenseInfo getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
+-    // repeated int32 version = 1 [packed = true];
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private DenseInfo(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++                version_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              version_.add(input.readInt32());
++              break;
++            }
++            case 10: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
++                version_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                version_.add(input.readInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 16: {
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                timestamp_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              timestamp_.add(input.readSInt64());
++              break;
++            }
++            case 18: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
++                timestamp_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                timestamp_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 24: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                changeset_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              changeset_.add(input.readSInt64());
++              break;
++            }
++            case 26: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
++                changeset_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                changeset_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 32: {
++              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++                uid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000008;
++              }
++              uid_.add(input.readSInt32());
++              break;
++            }
++            case 34: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008) && input.getBytesUntilLimit() > 0) {
++                uid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000008;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                uid_.add(input.readSInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 40: {
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++                userSid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              userSid_.add(input.readSInt32());
++              break;
++            }
++            case 42: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
++                userSid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                userSid_.add(input.readSInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 48: {
++              if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
++                visible_ = new java.util.ArrayList<java.lang.Boolean>();
++                mutable_bitField0_ |= 0x00000020;
++              }
++              visible_.add(input.readBool());
++              break;
++            }
++            case 50: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000020) == 0x00000020) && input.getBytesUntilLimit() > 0) {
++                visible_ = new java.util.ArrayList<java.lang.Boolean>();
++                mutable_bitField0_ |= 0x00000020;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                visible_.add(input.readBool());
++              }
++              input.popLimit(limit);
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++          version_ = java.util.Collections.unmodifiableList(version_);
++        }
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          timestamp_ = java.util.Collections.unmodifiableList(timestamp_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          changeset_ = java.util.Collections.unmodifiableList(changeset_);
++        }
++        if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++          uid_ = java.util.Collections.unmodifiableList(uid_);
++        }
++        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++          userSid_ = java.util.Collections.unmodifiableList(userSid_);
++        }
++        if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
++          visible_ = java.util.Collections.unmodifiableList(visible_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<DenseInfo> PARSER =
++        new com.google.protobuf.AbstractParser<DenseInfo>() {
++      public DenseInfo parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new DenseInfo(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<DenseInfo> getParserForType() {
++      return PARSER;
++    }
++
+     public static final int VERSION_FIELD_NUMBER = 1;
+     private java.util.List<java.lang.Integer> version_;
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     public java.util.List<java.lang.Integer>
+         getVersionList() {
+       return version_;
+     }
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     public int getVersionCount() {
+       return version_.size();
+     }
++    /**
++     * <code>repeated int32 version = 1 [packed = true];</code>
++     */
+     public int getVersion(int index) {
+       return version_.get(index);
+     }
+     private int versionMemoizedSerializedSize = -1;
+-    
+-    // repeated sint64 timestamp = 2 [packed = true];
++
+     public static final int TIMESTAMP_FIELD_NUMBER = 2;
+     private java.util.List<java.lang.Long> timestamp_;
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getTimestampList() {
+       return timestamp_;
+     }
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getTimestampCount() {
+       return timestamp_.size();
+     }
++    /**
++     * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getTimestamp(int index) {
+       return timestamp_.get(index);
+     }
+     private int timestampMemoizedSerializedSize = -1;
+-    
+-    // repeated sint64 changeset = 3 [packed = true];
++
+     public static final int CHANGESET_FIELD_NUMBER = 3;
+     private java.util.List<java.lang.Long> changeset_;
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getChangesetList() {
+       return changeset_;
+     }
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getChangesetCount() {
+       return changeset_.size();
+     }
++    /**
++     * <code>repeated sint64 changeset = 3 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getChangeset(int index) {
+       return changeset_.get(index);
+     }
+     private int changesetMemoizedSerializedSize = -1;
+-    
+-    // repeated sint32 uid = 4 [packed = true];
++
+     public static final int UID_FIELD_NUMBER = 4;
+     private java.util.List<java.lang.Integer> uid_;
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getUidList() {
+       return uid_;
+     }
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getUidCount() {
+       return uid_.size();
+     }
++    /**
++     * <code>repeated sint32 uid = 4 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getUid(int index) {
+       return uid_.get(index);
+     }
+     private int uidMemoizedSerializedSize = -1;
+-    
+-    // repeated sint32 user_sid = 5 [packed = true];
++
+     public static final int USER_SID_FIELD_NUMBER = 5;
+     private java.util.List<java.lang.Integer> userSid_;
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getUserSidList() {
+       return userSid_;
+     }
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     public int getUserSidCount() {
+       return userSid_.size();
+     }
++    /**
++     * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs for usernames. DELTA coded
++     * </pre>
++     */
+     public int getUserSid(int index) {
+       return userSid_.get(index);
+     }
+     private int userSidMemoizedSerializedSize = -1;
+-    
+-    // repeated bool visible = 6 [packed = true];
++
+     public static final int VISIBLE_FIELD_NUMBER = 6;
+     private java.util.List<java.lang.Boolean> visible_;
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     public java.util.List<java.lang.Boolean>
+         getVisibleList() {
+       return visible_;
+     }
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     public int getVisibleCount() {
+       return visible_.size();
+     }
++    /**
++     * <code>repeated bool visible = 6 [packed = true];</code>
++     *
++     * <pre>
++     * The visible flag is used to store history information. It indicates that
++     * the current object version has been created by a delete operation on the
++     * OSM API.
++     * When a writer sets this flag, it MUST add a required_features tag with
++     * value "HistoricalInformation" to the HeaderBlock.
++     * If this flag is not available for some object it MUST be assumed to be
++     * true if the file has the required_features tag "HistoricalInformation"
++     * set.
++     * </pre>
++     */
+     public boolean getVisible(int index) {
+       return visible_.get(index);
+     }
+     private int visibleMemoizedSerializedSize = -1;
+-    
++
+     private void initFields() {
+-      version_ = java.util.Collections.emptyList();;
+-      timestamp_ = java.util.Collections.emptyList();;
+-      changeset_ = java.util.Collections.emptyList();;
+-      uid_ = java.util.Collections.emptyList();;
+-      userSid_ = java.util.Collections.emptyList();;
+-      visible_ = java.util.Collections.emptyList();;
++      version_ = java.util.Collections.emptyList();
++      timestamp_ = java.util.Collections.emptyList();
++      changeset_ = java.util.Collections.emptyList();
++      uid_ = java.util.Collections.emptyList();
++      userSid_ = java.util.Collections.emptyList();
++      visible_ = java.util.Collections.emptyList();
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -4181,13 +6550,14 @@ public final class Osmformat {
+       for (int i = 0; i < visible_.size(); i++) {
+         output.writeBoolNoTag(visible_.get(i));
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       {
+         int dataSize = 0;
+@@ -4270,131 +6640,127 @@ public final class Osmformat {
+         }
+         visibleMemoizedSerializedSize = dataSize;
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.DenseInfo}
++     *
++     * <pre>
++     ** Optional metadata that may be included into each primitive. Special dense format used in DenseNodes. 
++     * </pre>
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfoOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.DenseInfo)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfoOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+-        version_ = java.util.Collections.emptyList();;
++        version_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+-        timestamp_ = java.util.Collections.emptyList();;
++        timestamp_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        changeset_ = java.util.Collections.emptyList();;
++        changeset_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+-        uid_ = java.util.Collections.emptyList();;
++        uid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000008);
+-        userSid_ = java.util.Collections.emptyList();;
++        userSid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+-        visible_ = java.util.Collections.emptyList();;
++        visible_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000020);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -4402,17 +6768,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo result = new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo(this);
+         int from_bitField0_ = bitField0_;
+@@ -4448,7 +6804,7 @@ public final class Osmformat {
+         result.visible_ = visible_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance()) return this;
+         if (!other.version_.isEmpty()) {
+@@ -4511,138 +6867,63 @@ public final class Osmformat {
+           }
+           
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              ensureVersionIsMutable();
+-              version_.add(input.readInt32());
+-              break;
+-            }
+-            case 10: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addVersion(input.readInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 16: {
+-              ensureTimestampIsMutable();
+-              timestamp_.add(input.readSInt64());
+-              break;
+-            }
+-            case 18: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addTimestamp(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 24: {
+-              ensureChangesetIsMutable();
+-              changeset_.add(input.readSInt64());
+-              break;
+-            }
+-            case 26: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addChangeset(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 32: {
+-              ensureUidIsMutable();
+-              uid_.add(input.readSInt32());
+-              break;
+-            }
+-            case 34: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addUid(input.readSInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 40: {
+-              ensureUserSidIsMutable();
+-              userSid_.add(input.readSInt32());
+-              break;
+-            }
+-            case 42: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addUserSid(input.readSInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 48: {
+-              ensureVisibleIsMutable();
+-              visible_.add(input.readBool());
+-              break;
+-            }
+-            case 50: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addVisible(input.readBool());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // repeated int32 version = 1 [packed = true];
+-      private java.util.List<java.lang.Integer> version_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> version_ = java.util.Collections.emptyList();
+       private void ensureVersionIsMutable() {
+         if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+           version_ = new java.util.ArrayList<java.lang.Integer>(version_);
+           bitField0_ |= 0x00000001;
+          }
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public java.util.List<java.lang.Integer>
+           getVersionList() {
+         return java.util.Collections.unmodifiableList(version_);
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public int getVersionCount() {
+         return version_.size();
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public int getVersion(int index) {
+         return version_.get(index);
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public Builder setVersion(
+           int index, int value) {
+         ensureVersionIsMutable();
+@@ -4650,44 +6931,81 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public Builder addVersion(int value) {
+         ensureVersionIsMutable();
+         version_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public Builder addAllVersion(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureVersionIsMutable();
+-        super.addAll(values, version_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, version_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 version = 1 [packed = true];</code>
++       */
+       public Builder clearVersion() {
+-        version_ = java.util.Collections.emptyList();;
++        version_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+         
+         return this;
+       }
+-      
+-      // repeated sint64 timestamp = 2 [packed = true];
+-      private java.util.List<java.lang.Long> timestamp_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> timestamp_ = java.util.Collections.emptyList();
+       private void ensureTimestampIsMutable() {
+         if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+           timestamp_ = new java.util.ArrayList<java.lang.Long>(timestamp_);
+           bitField0_ |= 0x00000002;
+          }
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getTimestampList() {
+         return java.util.Collections.unmodifiableList(timestamp_);
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getTimestampCount() {
+         return timestamp_.size();
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getTimestamp(int index) {
+         return timestamp_.get(index);
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setTimestamp(
+           int index, long value) {
+         ensureTimestampIsMutable();
+@@ -4695,44 +7013,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addTimestamp(long value) {
+         ensureTimestampIsMutable();
+         timestamp_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllTimestamp(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureTimestampIsMutable();
+-        super.addAll(values, timestamp_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, timestamp_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 timestamp = 2 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearTimestamp() {
+-        timestamp_ = java.util.Collections.emptyList();;
++        timestamp_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+         
+         return this;
+       }
+-      
+-      // repeated sint64 changeset = 3 [packed = true];
+-      private java.util.List<java.lang.Long> changeset_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> changeset_ = java.util.Collections.emptyList();
+       private void ensureChangesetIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+           changeset_ = new java.util.ArrayList<java.lang.Long>(changeset_);
+           bitField0_ |= 0x00000004;
+          }
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getChangesetList() {
+         return java.util.Collections.unmodifiableList(changeset_);
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getChangesetCount() {
+         return changeset_.size();
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getChangeset(int index) {
+         return changeset_.get(index);
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setChangeset(
+           int index, long value) {
+         ensureChangesetIsMutable();
+@@ -4740,44 +7107,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addChangeset(long value) {
+         ensureChangesetIsMutable();
+         changeset_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllChangeset(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureChangesetIsMutable();
+-        super.addAll(values, changeset_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, changeset_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 changeset = 3 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearChangeset() {
+-        changeset_ = java.util.Collections.emptyList();;
++        changeset_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      
+-      // repeated sint32 uid = 4 [packed = true];
+-      private java.util.List<java.lang.Integer> uid_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> uid_ = java.util.Collections.emptyList();
+       private void ensureUidIsMutable() {
+         if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+           uid_ = new java.util.ArrayList<java.lang.Integer>(uid_);
+           bitField0_ |= 0x00000008;
+          }
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getUidList() {
+         return java.util.Collections.unmodifiableList(uid_);
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getUidCount() {
+         return uid_.size();
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getUid(int index) {
+         return uid_.get(index);
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setUid(
+           int index, int value) {
+         ensureUidIsMutable();
+@@ -4785,44 +7201,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addUid(int value) {
+         ensureUidIsMutable();
+         uid_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllUid(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureUidIsMutable();
+-        super.addAll(values, uid_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, uid_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 uid = 4 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearUid() {
+-        uid_ = java.util.Collections.emptyList();;
++        uid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000008);
+         
+         return this;
+       }
+-      
+-      // repeated sint32 user_sid = 5 [packed = true];
+-      private java.util.List<java.lang.Integer> userSid_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> userSid_ = java.util.Collections.emptyList();
+       private void ensureUserSidIsMutable() {
+         if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+           userSid_ = new java.util.ArrayList<java.lang.Integer>(userSid_);
+           bitField0_ |= 0x00000010;
+          }
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getUserSidList() {
+         return java.util.Collections.unmodifiableList(userSid_);
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public int getUserSidCount() {
+         return userSid_.size();
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public int getUserSid(int index) {
+         return userSid_.get(index);
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public Builder setUserSid(
+           int index, int value) {
+         ensureUserSidIsMutable();
+@@ -4830,44 +7295,121 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public Builder addUserSid(int value) {
+         ensureUserSidIsMutable();
+         userSid_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public Builder addAllUserSid(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureUserSidIsMutable();
+-        super.addAll(values, userSid_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, userSid_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint32 user_sid = 5 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs for usernames. DELTA coded
++       * </pre>
++       */
+       public Builder clearUserSid() {
+-        userSid_ = java.util.Collections.emptyList();;
++        userSid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         
+         return this;
+       }
+-      
+-      // repeated bool visible = 6 [packed = true];
+-      private java.util.List<java.lang.Boolean> visible_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Boolean> visible_ = java.util.Collections.emptyList();
+       private void ensureVisibleIsMutable() {
+         if (!((bitField0_ & 0x00000020) == 0x00000020)) {
+           visible_ = new java.util.ArrayList<java.lang.Boolean>(visible_);
+           bitField0_ |= 0x00000020;
+          }
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public java.util.List<java.lang.Boolean>
+           getVisibleList() {
+         return java.util.Collections.unmodifiableList(visible_);
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public int getVisibleCount() {
+         return visible_.size();
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public boolean getVisible(int index) {
+         return visible_.get(index);
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder setVisible(
+           int index, boolean value) {
+         ensureVisibleIsMutable();
+@@ -4875,81 +7417,243 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder addVisible(boolean value) {
+         ensureVisibleIsMutable();
+         visible_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder addAllVisible(
+           java.lang.Iterable<? extends java.lang.Boolean> values) {
+         ensureVisibleIsMutable();
+-        super.addAll(values, visible_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, visible_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated bool visible = 6 [packed = true];</code>
++       *
++       * <pre>
++       * The visible flag is used to store history information. It indicates that
++       * the current object version has been created by a delete operation on the
++       * OSM API.
++       * When a writer sets this flag, it MUST add a required_features tag with
++       * value "HistoricalInformation" to the HeaderBlock.
++       * If this flag is not available for some object it MUST be assumed to be
++       * true if the file has the required_features tag "HistoricalInformation"
++       * set.
++       * </pre>
++       */
+       public Builder clearVisible() {
+-        visible_ = java.util.Collections.emptyList();;
++        visible_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000020);
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.DenseInfo)
+     }
+-    
++
+     static {
+       defaultInstance = new DenseInfo(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.DenseInfo)
+   }
+-  
+-  public interface ChangeSetOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required int64 id = 1;
++
++  public interface ChangeSetOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.ChangeSet)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required int64 id = 1;</code>
++     *
++     * <pre>
++     *   
++     *   // Parallel arrays.
++     *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++     *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++     *   optional Info info = 4;
++     * </pre>
++     */
+     boolean hasId();
++    /**
++     * <code>required int64 id = 1;</code>
++     *
++     * <pre>
++     *   
++     *   // Parallel arrays.
++     *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++     *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++     *   optional Info info = 4;
++     * </pre>
++     */
+     long getId();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.ChangeSet}
++   *
++   * <pre>
++   * THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
++   * TODO:    REMOVE THIS?
++   * </pre>
++   */
+   public static final class ChangeSet extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements ChangeSetOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.ChangeSet)
++      ChangeSetOrBuilder {
+     // Use ChangeSet.newBuilder() to construct.
+-    private ChangeSet(Builder builder) {
++    private ChangeSet(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private ChangeSet(boolean noInit) {}
+-    
++    private ChangeSet(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final ChangeSet defaultInstance;
+     public static ChangeSet getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public ChangeSet getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private ChangeSet(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              id_ = input.readInt64();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<ChangeSet> PARSER =
++        new com.google.protobuf.AbstractParser<ChangeSet>() {
++      public ChangeSet parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new ChangeSet(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<ChangeSet> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // required int64 id = 1;
+     public static final int ID_FIELD_NUMBER = 1;
+     private long id_;
++    /**
++     * <code>required int64 id = 1;</code>
++     *
++     * <pre>
++     *   
++     *   // Parallel arrays.
++     *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++     *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++     *   optional Info info = 4;
++     * </pre>
++     */
+     public boolean hasId() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>required int64 id = 1;</code>
++     *
++     * <pre>
++     *   
++     *   // Parallel arrays.
++     *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++     *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++     *   optional Info info = 4;
++     * </pre>
++     */
+     public long getId() {
+       return id_;
+     }
+-    
++
+     private void initFields() {
+       id_ = 0L;
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasId()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -4957,140 +7661,138 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         output.writeInt64(1, id_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+           .computeInt64Size(1, id_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.ChangeSet}
++     *
++     * <pre>
++     * THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
++     * TODO:    REMOVE THIS?
++     * </pre>
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.ChangeSet)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSetOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         id_ = 0L;
+         bitField0_ = (bitField0_ & ~0x00000001);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -5098,17 +7800,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet result = new org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet(this);
+         int from_bitField0_ = bitField0_;
+@@ -5120,15 +7812,17 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet.getDefaultInstance()) return this;
+         if (other.hasId()) {
+           setId(other.getId());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasId()) {
+           
+@@ -5136,189 +7830,501 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              id_ = input.readInt64();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.ChangeSet) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required int64 id = 1;
++
+       private long id_ ;
++      /**
++       * <code>required int64 id = 1;</code>
++       *
++       * <pre>
++       *   
++       *   // Parallel arrays.
++       *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++       *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++       *   optional Info info = 4;
++       * </pre>
++       */
+       public boolean hasId() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       *
++       * <pre>
++       *   
++       *   // Parallel arrays.
++       *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++       *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++       *   optional Info info = 4;
++       * </pre>
++       */
+       public long getId() {
+         return id_;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       *
++       * <pre>
++       *   
++       *   // Parallel arrays.
++       *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++       *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++       *   optional Info info = 4;
++       * </pre>
++       */
+       public Builder setId(long value) {
+         bitField0_ |= 0x00000001;
+         id_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       *
++       * <pre>
++       *   
++       *   // Parallel arrays.
++       *   repeated uint32 keys = 2 [packed = true]; // String IDs.
++       *   repeated uint32 vals = 3 [packed = true]; // String IDs.
++       *   optional Info info = 4;
++       * </pre>
++       */
+       public Builder clearId() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         id_ = 0L;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.ChangeSet)
+     }
+-    
++
+     static {
+       defaultInstance = new ChangeSet(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.ChangeSet)
+   }
+-  
+-  public interface NodeOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required sint64 id = 1;
++
++  public interface NodeOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.Node)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required sint64 id = 1;</code>
++     */
+     boolean hasId();
++    /**
++     * <code>required sint64 id = 1;</code>
++     */
+     long getId();
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getKeysList();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeysCount();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeys(int index);
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getValsList();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     int getValsCount();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     int getVals(int index);
+-    
+-    // optional .OSMPBF.Info info = 4;
++
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     *
++     * <pre>
++     * May be omitted in omitmeta
++     * </pre>
++     */
+     boolean hasInfo();
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     *
++     * <pre>
++     * May be omitted in omitmeta
++     * </pre>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+-    
+-    // required sint64 lat = 8;
++
++    /**
++     * <code>required sint64 lat = 8;</code>
++     */
+     boolean hasLat();
++    /**
++     * <code>required sint64 lat = 8;</code>
++     */
+     long getLat();
+-    
+-    // required sint64 lon = 9;
++
++    /**
++     * <code>required sint64 lon = 9;</code>
++     */
+     boolean hasLon();
++    /**
++     * <code>required sint64 lon = 9;</code>
++     */
+     long getLon();
+   }
++  /**
++   * Protobuf type {@code OSMPBF.Node}
++   */
+   public static final class Node extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements NodeOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.Node)
++      NodeOrBuilder {
+     // Use Node.newBuilder() to construct.
+-    private Node(Builder builder) {
++    private Node(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private Node(boolean noInit) {}
+-    
++    private Node(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final Node defaultInstance;
+     public static Node getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public Node getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private Node(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              id_ = input.readSInt64();
++              break;
++            }
++            case 16: {
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              keys_.add(input.readUInt32());
++              break;
++            }
++            case 18: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                keys_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 24: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              vals_.add(input.readUInt32());
++              break;
++            }
++            case 26: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                vals_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 34: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000002) == 0x00000002)) {
++                subBuilder = info_.toBuilder();
++              }
++              info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(info_);
++                info_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000002;
++              break;
++            }
++            case 64: {
++              bitField0_ |= 0x00000004;
++              lat_ = input.readSInt64();
++              break;
++            }
++            case 72: {
++              bitField0_ |= 0x00000008;
++              lon_ = input.readSInt64();
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          keys_ = java.util.Collections.unmodifiableList(keys_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          vals_ = java.util.Collections.unmodifiableList(vals_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<Node> PARSER =
++        new com.google.protobuf.AbstractParser<Node>() {
++      public Node parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new Node(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<Node> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // required sint64 id = 1;
+     public static final int ID_FIELD_NUMBER = 1;
+     private long id_;
++    /**
++     * <code>required sint64 id = 1;</code>
++     */
+     public boolean hasId() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>required sint64 id = 1;</code>
++     */
+     public long getId() {
+       return id_;
+     }
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
+     public static final int KEYS_FIELD_NUMBER = 2;
+     private java.util.List<java.lang.Integer> keys_;
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getKeysList() {
+       return keys_;
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeysCount() {
+       return keys_.size();
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeys(int index) {
+       return keys_.get(index);
+     }
+     private int keysMemoizedSerializedSize = -1;
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
+     public static final int VALS_FIELD_NUMBER = 3;
+     private java.util.List<java.lang.Integer> vals_;
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getValsList() {
+       return vals_;
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     public int getValsCount() {
+       return vals_.size();
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     *
++     * <pre>
++     * String IDs.
++     * </pre>
++     */
+     public int getVals(int index) {
+       return vals_.get(index);
+     }
+     private int valsMemoizedSerializedSize = -1;
+-    
+-    // optional .OSMPBF.Info info = 4;
++
+     public static final int INFO_FIELD_NUMBER = 4;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     *
++     * <pre>
++     * May be omitted in omitmeta
++     * </pre>
++     */
+     public boolean hasInfo() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     *
++     * <pre>
++     * May be omitted in omitmeta
++     * </pre>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+       return info_;
+     }
+-    
+-    // required sint64 lat = 8;
++
+     public static final int LAT_FIELD_NUMBER = 8;
+     private long lat_;
++    /**
++     * <code>required sint64 lat = 8;</code>
++     */
+     public boolean hasLat() {
+       return ((bitField0_ & 0x00000004) == 0x00000004);
+     }
++    /**
++     * <code>required sint64 lat = 8;</code>
++     */
+     public long getLat() {
+       return lat_;
+     }
+-    
+-    // required sint64 lon = 9;
++
+     public static final int LON_FIELD_NUMBER = 9;
+     private long lon_;
++    /**
++     * <code>required sint64 lon = 9;</code>
++     */
+     public boolean hasLon() {
+       return ((bitField0_ & 0x00000008) == 0x00000008);
+     }
++    /**
++     * <code>required sint64 lon = 9;</code>
++     */
+     public long getLon() {
+       return lon_;
+     }
+-    
++
+     private void initFields() {
+       id_ = 0L;
+-      keys_ = java.util.Collections.emptyList();;
+-      vals_ = java.util.Collections.emptyList();;
++      keys_ = java.util.Collections.emptyList();
++      vals_ = java.util.Collections.emptyList();
+       info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+       lat_ = 0L;
+       lon_ = 0L;
+@@ -5326,8 +8332,9 @@ public final class Osmformat {
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasId()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -5343,7 +8350,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -5373,13 +8380,14 @@ public final class Osmformat {
+       if (((bitField0_ & 0x00000008) == 0x00000008)) {
+         output.writeSInt64(9, lon_);
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -5425,113 +8433,105 @@ public final class Osmformat {
+         size += com.google.protobuf.CodedOutputStream
+           .computeSInt64Size(9, lon_);
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Node parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Node prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.Node}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Node, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.NodeOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.Node)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.NodeOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Node.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         id_ = 0L;
+         bitField0_ = (bitField0_ & ~0x00000001);
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+         bitField0_ = (bitField0_ & ~0x00000008);
+@@ -5541,15 +8541,15 @@ public final class Osmformat {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Node getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.Node.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Node build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Node result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -5557,17 +8557,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.Node buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.Node result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Node buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Node result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Node(this);
+         int from_bitField0_ = bitField0_;
+@@ -5601,7 +8591,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Node other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Node.getDefaultInstance()) return this;
+         if (other.hasId()) {
+@@ -5636,9 +8626,11 @@ public final class Osmformat {
+         if (other.hasLon()) {
+           setLon(other.getLon());
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasId()) {
+           
+@@ -5654,121 +8646,103 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              id_ = input.readSInt64();
+-              break;
+-            }
+-            case 16: {
+-              ensureKeysIsMutable();
+-              keys_.add(input.readUInt32());
+-              break;
+-            }
+-            case 18: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addKeys(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 24: {
+-              ensureValsIsMutable();
+-              vals_.add(input.readUInt32());
+-              break;
+-            }
+-            case 26: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addVals(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 34: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder();
+-              if (hasInfo()) {
+-                subBuilder.mergeFrom(getInfo());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setInfo(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 64: {
+-              bitField0_ |= 0x00000010;
+-              lat_ = input.readSInt64();
+-              break;
+-            }
+-            case 72: {
+-              bitField0_ |= 0x00000020;
+-              lon_ = input.readSInt64();
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.Node parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Node) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required sint64 id = 1;
++
+       private long id_ ;
++      /**
++       * <code>required sint64 id = 1;</code>
++       */
+       public boolean hasId() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required sint64 id = 1;</code>
++       */
+       public long getId() {
+         return id_;
+       }
++      /**
++       * <code>required sint64 id = 1;</code>
++       */
+       public Builder setId(long value) {
+         bitField0_ |= 0x00000001;
+         id_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 id = 1;</code>
++       */
+       public Builder clearId() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         id_ = 0L;
+         
+         return this;
+       }
+-      
+-      // repeated uint32 keys = 2 [packed = true];
+-      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+       private void ensureKeysIsMutable() {
+         if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+           keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+           bitField0_ |= 0x00000002;
+          }
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getKeysList() {
+         return java.util.Collections.unmodifiableList(keys_);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeysCount() {
+         return keys_.size();
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeys(int index) {
+         return keys_.get(index);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder setKeys(
+           int index, int value) {
+         ensureKeysIsMutable();
+@@ -5776,44 +8750,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addKeys(int value) {
+         ensureKeysIsMutable();
+         keys_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addAllKeys(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureKeysIsMutable();
+-        super.addAll(values, keys_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, keys_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder clearKeys() {
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+         
+         return this;
+       }
+-      
+-      // repeated uint32 vals = 3 [packed = true];
+-      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+       private void ensureValsIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+           vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+           bitField0_ |= 0x00000004;
+          }
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getValsList() {
+         return java.util.Collections.unmodifiableList(vals_);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public int getValsCount() {
+         return vals_.size();
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public int getVals(int index) {
+         return vals_.get(index);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public Builder setVals(
+           int index, int value) {
+         ensureValsIsMutable();
+@@ -5821,50 +8844,106 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public Builder addVals(int value) {
+         ensureValsIsMutable();
+         vals_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public Builder addAllVals(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureValsIsMutable();
+-        super.addAll(values, vals_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, vals_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       *
++       * <pre>
++       * String IDs.
++       * </pre>
++       */
+       public Builder clearVals() {
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      
+-      // optional .OSMPBF.Info info = 4;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public boolean hasInfo() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+         return info_;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         info_ = value;
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public Builder setInfo(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+         info_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (((bitField0_ & 0x00000008) == 0x00000008) &&
+             info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+@@ -5873,202 +8952,593 @@ public final class Osmformat {
+         } else {
+           info_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       *
++       * <pre>
++       * May be omitted in omitmeta
++       * </pre>
++       */
+       public Builder clearInfo() {
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000008);
+         return this;
+       }
+-      
+-      // required sint64 lat = 8;
++
+       private long lat_ ;
++      /**
++       * <code>required sint64 lat = 8;</code>
++       */
+       public boolean hasLat() {
+         return ((bitField0_ & 0x00000010) == 0x00000010);
+       }
++      /**
++       * <code>required sint64 lat = 8;</code>
++       */
+       public long getLat() {
+         return lat_;
+       }
++      /**
++       * <code>required sint64 lat = 8;</code>
++       */
+       public Builder setLat(long value) {
+         bitField0_ |= 0x00000010;
+         lat_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 lat = 8;</code>
++       */
+       public Builder clearLat() {
+         bitField0_ = (bitField0_ & ~0x00000010);
+         lat_ = 0L;
+         
+         return this;
+       }
+-      
+-      // required sint64 lon = 9;
++
+       private long lon_ ;
++      /**
++       * <code>required sint64 lon = 9;</code>
++       */
+       public boolean hasLon() {
+         return ((bitField0_ & 0x00000020) == 0x00000020);
+       }
++      /**
++       * <code>required sint64 lon = 9;</code>
++       */
+       public long getLon() {
+         return lon_;
+       }
++      /**
++       * <code>required sint64 lon = 9;</code>
++       */
+       public Builder setLon(long value) {
+         bitField0_ |= 0x00000020;
+         lon_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required sint64 lon = 9;</code>
++       */
+       public Builder clearLon() {
+         bitField0_ = (bitField0_ & ~0x00000020);
+         lon_ = 0L;
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.Node)
+     }
+-    
++
+     static {
+       defaultInstance = new Node(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.Node)
+   }
+-  
+-  public interface DenseNodesOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // repeated sint64 id = 1 [packed = true];
++
++  public interface DenseNodesOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.DenseNodes)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getIdList();
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getIdCount();
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getId(int index);
+-    
+-    // optional .OSMPBF.DenseInfo denseinfo = 5;
++
++    /**
++     * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++     *
++     * <pre>
++     *repeated Info info = 4;
++     * </pre>
++     */
+     boolean hasDenseinfo();
++    /**
++     * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++     *
++     * <pre>
++     *repeated Info info = 4;
++     * </pre>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo();
+-    
+-    // repeated sint64 lat = 8 [packed = true];
++
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getLatList();
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getLatCount();
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getLat(int index);
+-    
+-    // repeated sint64 lon = 9 [packed = true];
++
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getLonList();
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getLonCount();
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getLon(int index);
+-    
+-    // repeated int32 keys_vals = 10 [packed = true];
++
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getKeysValsList();
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     int getKeysValsCount();
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     int getKeysVals(int index);
+   }
++  /**
++   * Protobuf type {@code OSMPBF.DenseNodes}
++   */
+   public static final class DenseNodes extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements DenseNodesOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.DenseNodes)
++      DenseNodesOrBuilder {
+     // Use DenseNodes.newBuilder() to construct.
+-    private DenseNodes(Builder builder) {
++    private DenseNodes(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private DenseNodes(boolean noInit) {}
+-    
++    private DenseNodes(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final DenseNodes defaultInstance;
+     public static DenseNodes getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public DenseNodes getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private DenseNodes(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++                id_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              id_.add(input.readSInt64());
++              break;
++            }
++            case 10: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
++                id_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000001;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                id_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 42: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000001) == 0x00000001)) {
++                subBuilder = denseinfo_.toBuilder();
++              }
++              denseinfo_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(denseinfo_);
++                denseinfo_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000001;
++              break;
++            }
++            case 64: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                lat_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              lat_.add(input.readSInt64());
++              break;
++            }
++            case 66: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
++                lat_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                lat_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 72: {
++              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++                lon_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000008;
++              }
++              lon_.add(input.readSInt64());
++              break;
++            }
++            case 74: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000008) == 0x00000008) && input.getBytesUntilLimit() > 0) {
++                lon_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000008;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                lon_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 80: {
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++                keysVals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              keysVals_.add(input.readInt32());
++              break;
++            }
++            case 82: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
++                keysVals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                keysVals_.add(input.readInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
++          id_ = java.util.Collections.unmodifiableList(id_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          lat_ = java.util.Collections.unmodifiableList(lat_);
++        }
++        if (((mutable_bitField0_ & 0x00000008) == 0x00000008)) {
++          lon_ = java.util.Collections.unmodifiableList(lon_);
++        }
++        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++          keysVals_ = java.util.Collections.unmodifiableList(keysVals_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<DenseNodes> PARSER =
++        new com.google.protobuf.AbstractParser<DenseNodes>() {
++      public DenseNodes parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new DenseNodes(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<DenseNodes> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // repeated sint64 id = 1 [packed = true];
+     public static final int ID_FIELD_NUMBER = 1;
+     private java.util.List<java.lang.Long> id_;
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getIdList() {
+       return id_;
+     }
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getIdCount() {
+       return id_.size();
+     }
++    /**
++     * <code>repeated sint64 id = 1 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getId(int index) {
+       return id_.get(index);
+     }
+     private int idMemoizedSerializedSize = -1;
+-    
+-    // optional .OSMPBF.DenseInfo denseinfo = 5;
++
+     public static final int DENSEINFO_FIELD_NUMBER = 5;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo denseinfo_;
++    /**
++     * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++     *
++     * <pre>
++     *repeated Info info = 4;
++     * </pre>
++     */
+     public boolean hasDenseinfo() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++     *
++     * <pre>
++     *repeated Info info = 4;
++     * </pre>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo() {
+       return denseinfo_;
+     }
+-    
+-    // repeated sint64 lat = 8 [packed = true];
++
+     public static final int LAT_FIELD_NUMBER = 8;
+     private java.util.List<java.lang.Long> lat_;
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getLatList() {
+       return lat_;
+     }
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getLatCount() {
+       return lat_.size();
+     }
++    /**
++     * <code>repeated sint64 lat = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getLat(int index) {
+       return lat_.get(index);
+     }
+     private int latMemoizedSerializedSize = -1;
+-    
+-    // repeated sint64 lon = 9 [packed = true];
++
+     public static final int LON_FIELD_NUMBER = 9;
+     private java.util.List<java.lang.Long> lon_;
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getLonList() {
+       return lon_;
+     }
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getLonCount() {
+       return lon_.size();
+     }
++    /**
++     * <code>repeated sint64 lon = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getLon(int index) {
+       return lon_.get(index);
+     }
+     private int lonMemoizedSerializedSize = -1;
+-    
+-    // repeated int32 keys_vals = 10 [packed = true];
++
+     public static final int KEYS_VALS_FIELD_NUMBER = 10;
+     private java.util.List<java.lang.Integer> keysVals_;
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getKeysValsList() {
+       return keysVals_;
+     }
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     public int getKeysValsCount() {
+       return keysVals_.size();
+     }
++    /**
++     * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++     *
++     * <pre>
++     * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++     * </pre>
++     */
+     public int getKeysVals(int index) {
+       return keysVals_.get(index);
+     }
+     private int keysValsMemoizedSerializedSize = -1;
+-    
++
+     private void initFields() {
+-      id_ = java.util.Collections.emptyList();;
++      id_ = java.util.Collections.emptyList();
+       denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+-      lat_ = java.util.Collections.emptyList();;
+-      lon_ = java.util.Collections.emptyList();;
+-      keysVals_ = java.util.Collections.emptyList();;
++      lat_ = java.util.Collections.emptyList();
++      lon_ = java.util.Collections.emptyList();
++      keysVals_ = java.util.Collections.emptyList();
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -6103,13 +9573,14 @@ public final class Osmformat {
+       for (int i = 0; i < keysVals_.size(); i++) {
+         output.writeInt32NoTag(keysVals_.get(i));
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       {
+         int dataSize = 0;
+@@ -6171,129 +9642,121 @@ public final class Osmformat {
+         }
+         keysValsMemoizedSerializedSize = dataSize;
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.DenseNodes}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodesOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.DenseNodes)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodesOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+-        id_ = java.util.Collections.emptyList();;
++        id_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+         denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        lat_ = java.util.Collections.emptyList();;
++        lat_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+-        lon_ = java.util.Collections.emptyList();;
++        lon_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000008);
+-        keysVals_ = java.util.Collections.emptyList();;
++        keysVals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -6301,17 +9764,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes result = new org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes(this);
+         int from_bitField0_ = bitField0_;
+@@ -6343,7 +9796,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes.getDefaultInstance()) return this;
+         if (!other.id_.isEmpty()) {
+@@ -6389,119 +9842,79 @@ public final class Osmformat {
+           }
+           
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              ensureIdIsMutable();
+-              id_.add(input.readSInt64());
+-              break;
+-            }
+-            case 10: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addId(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 42: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.newBuilder();
+-              if (hasDenseinfo()) {
+-                subBuilder.mergeFrom(getDenseinfo());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setDenseinfo(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 64: {
+-              ensureLatIsMutable();
+-              lat_.add(input.readSInt64());
+-              break;
+-            }
+-            case 66: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addLat(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 72: {
+-              ensureLonIsMutable();
+-              lon_.add(input.readSInt64());
+-              break;
+-            }
+-            case 74: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addLon(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 80: {
+-              ensureKeysValsIsMutable();
+-              keysVals_.add(input.readInt32());
+-              break;
+-            }
+-            case 82: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addKeysVals(input.readInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.DenseNodes) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // repeated sint64 id = 1 [packed = true];
+-      private java.util.List<java.lang.Long> id_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> id_ = java.util.Collections.emptyList();
+       private void ensureIdIsMutable() {
+         if (!((bitField0_ & 0x00000001) == 0x00000001)) {
+           id_ = new java.util.ArrayList<java.lang.Long>(id_);
+           bitField0_ |= 0x00000001;
+          }
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getIdList() {
+         return java.util.Collections.unmodifiableList(id_);
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getIdCount() {
+         return id_.size();
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getId(int index) {
+         return id_.get(index);
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setId(
+           int index, long value) {
+         ensureIdIsMutable();
+@@ -6509,50 +9922,106 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addId(long value) {
+         ensureIdIsMutable();
+         id_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllId(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureIdIsMutable();
+-        super.addAll(values, id_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, id_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 id = 1 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearId() {
+-        id_ = java.util.Collections.emptyList();;
++        id_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000001);
+         
+         return this;
+       }
+-      
+-      // optional .OSMPBF.DenseInfo denseinfo = 5;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public boolean hasDenseinfo() {
+         return ((bitField0_ & 0x00000002) == 0x00000002);
+       }
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo getDenseinfo() {
+         return denseinfo_;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public Builder setDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         denseinfo_ = value;
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public Builder setDenseinfo(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.Builder builderForValue) {
+         denseinfo_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public Builder mergeDenseinfo(org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo value) {
+         if (((bitField0_ & 0x00000002) == 0x00000002) &&
+             denseinfo_ != org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance()) {
+@@ -6561,35 +10030,69 @@ public final class Osmformat {
+         } else {
+           denseinfo_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000002;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.DenseInfo denseinfo = 5;</code>
++       *
++       * <pre>
++       *repeated Info info = 4;
++       * </pre>
++       */
+       public Builder clearDenseinfo() {
+         denseinfo_ = org.openstreetmap.osmosis.osmbinary.Osmformat.DenseInfo.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000002);
+         return this;
+       }
+-      
+-      // repeated sint64 lat = 8 [packed = true];
+-      private java.util.List<java.lang.Long> lat_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> lat_ = java.util.Collections.emptyList();
+       private void ensureLatIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+           lat_ = new java.util.ArrayList<java.lang.Long>(lat_);
+           bitField0_ |= 0x00000004;
+          }
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getLatList() {
+         return java.util.Collections.unmodifiableList(lat_);
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getLatCount() {
+         return lat_.size();
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getLat(int index) {
+         return lat_.get(index);
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setLat(
+           int index, long value) {
+         ensureLatIsMutable();
+@@ -6597,44 +10100,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addLat(long value) {
+         ensureLatIsMutable();
+         lat_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllLat(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureLatIsMutable();
+-        super.addAll(values, lat_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, lat_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lat = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearLat() {
+-        lat_ = java.util.Collections.emptyList();;
++        lat_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      
+-      // repeated sint64 lon = 9 [packed = true];
+-      private java.util.List<java.lang.Long> lon_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> lon_ = java.util.Collections.emptyList();
+       private void ensureLonIsMutable() {
+         if (!((bitField0_ & 0x00000008) == 0x00000008)) {
+           lon_ = new java.util.ArrayList<java.lang.Long>(lon_);
+           bitField0_ |= 0x00000008;
+          }
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getLonList() {
+         return java.util.Collections.unmodifiableList(lon_);
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getLonCount() {
+         return lon_.size();
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getLon(int index) {
+         return lon_.get(index);
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setLon(
+           int index, long value) {
+         ensureLonIsMutable();
+@@ -6642,44 +10194,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addLon(long value) {
+         ensureLonIsMutable();
+         lon_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllLon(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureLonIsMutable();
+-        super.addAll(values, lon_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, lon_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 lon = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearLon() {
+-        lon_ = java.util.Collections.emptyList();;
++        lon_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000008);
+         
+         return this;
+       }
+-      
+-      // repeated int32 keys_vals = 10 [packed = true];
+-      private java.util.List<java.lang.Integer> keysVals_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> keysVals_ = java.util.Collections.emptyList();
+       private void ensureKeysValsIsMutable() {
+         if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+           keysVals_ = new java.util.ArrayList<java.lang.Integer>(keysVals_);
+           bitField0_ |= 0x00000010;
+          }
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getKeysValsList() {
+         return java.util.Collections.unmodifiableList(keysVals_);
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public int getKeysValsCount() {
+         return keysVals_.size();
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public int getKeysVals(int index) {
+         return keysVals_.get(index);
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public Builder setKeysVals(
+           int index, int value) {
+         ensureKeysValsIsMutable();
+@@ -6687,159 +10288,454 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public Builder addKeysVals(int value) {
+         ensureKeysValsIsMutable();
+         keysVals_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public Builder addAllKeysVals(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureKeysValsIsMutable();
+-        super.addAll(values, keysVals_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, keysVals_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 keys_vals = 10 [packed = true];</code>
++       *
++       * <pre>
++       * Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
++       * </pre>
++       */
+       public Builder clearKeysVals() {
+-        keysVals_ = java.util.Collections.emptyList();;
++        keysVals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.DenseNodes)
+     }
+-    
++
+     static {
+       defaultInstance = new DenseNodes(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.DenseNodes)
+   }
+-  
+-  public interface WayOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required int64 id = 1;
++
++  public interface WayOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.Way)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     boolean hasId();
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     long getId();
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getKeysList();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeysCount();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeys(int index);
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     java.util.List<java.lang.Integer> getValsList();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     int getValsCount();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     int getVals(int index);
+-    
+-    // optional .OSMPBF.Info info = 4;
++
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     boolean hasInfo();
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+-    
+-    // repeated sint64 refs = 8 [packed = true];
++
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getRefsList();
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     int getRefsCount();
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     long getRefs(int index);
+   }
++  /**
++   * Protobuf type {@code OSMPBF.Way}
++   */
+   public static final class Way extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements WayOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.Way)
++      WayOrBuilder {
+     // Use Way.newBuilder() to construct.
+-    private Way(Builder builder) {
++    private Way(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private Way(boolean noInit) {}
+-    
++    private Way(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final Way defaultInstance;
+     public static Way getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public Way getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private Way(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              id_ = input.readInt64();
++              break;
++            }
++            case 16: {
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              keys_.add(input.readUInt32());
++              break;
++            }
++            case 18: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                keys_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 24: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              vals_.add(input.readUInt32());
++              break;
++            }
++            case 26: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                vals_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 34: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000002) == 0x00000002)) {
++                subBuilder = info_.toBuilder();
++              }
++              info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(info_);
++                info_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000002;
++              break;
++            }
++            case 64: {
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++                refs_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              refs_.add(input.readSInt64());
++              break;
++            }
++            case 66: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
++                refs_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                refs_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          keys_ = java.util.Collections.unmodifiableList(keys_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          vals_ = java.util.Collections.unmodifiableList(vals_);
++        }
++        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++          refs_ = java.util.Collections.unmodifiableList(refs_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<Way> PARSER =
++        new com.google.protobuf.AbstractParser<Way>() {
++      public Way parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new Way(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<Way> getParserForType() {
++      return PARSER;
++    }
++
+     private int bitField0_;
+-    // required int64 id = 1;
+     public static final int ID_FIELD_NUMBER = 1;
+     private long id_;
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     public boolean hasId() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     public long getId() {
+       return id_;
+     }
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
+     public static final int KEYS_FIELD_NUMBER = 2;
+     private java.util.List<java.lang.Integer> keys_;
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getKeysList() {
+       return keys_;
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeysCount() {
+       return keys_.size();
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeys(int index) {
+       return keys_.get(index);
+     }
+     private int keysMemoizedSerializedSize = -1;
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
+     public static final int VALS_FIELD_NUMBER = 3;
+     private java.util.List<java.lang.Integer> vals_;
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public java.util.List<java.lang.Integer>
+         getValsList() {
+       return vals_;
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public int getValsCount() {
+       return vals_.size();
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public int getVals(int index) {
+       return vals_.get(index);
+     }
+     private int valsMemoizedSerializedSize = -1;
+-    
+-    // optional .OSMPBF.Info info = 4;
++
+     public static final int INFO_FIELD_NUMBER = 4;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     public boolean hasInfo() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+       return info_;
+     }
+-    
+-    // repeated sint64 refs = 8 [packed = true];
++
+     public static final int REFS_FIELD_NUMBER = 8;
+     private java.util.List<java.lang.Long> refs_;
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getRefsList() {
+       return refs_;
+     }
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public int getRefsCount() {
+       return refs_.size();
+     }
++    /**
++     * <code>repeated sint64 refs = 8 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA coded
++     * </pre>
++     */
+     public long getRefs(int index) {
+       return refs_.get(index);
+     }
+     private int refsMemoizedSerializedSize = -1;
+-    
++
+     private void initFields() {
+       id_ = 0L;
+-      keys_ = java.util.Collections.emptyList();;
+-      vals_ = java.util.Collections.emptyList();;
++      keys_ = java.util.Collections.emptyList();
++      vals_ = java.util.Collections.emptyList();
+       info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-      refs_ = java.util.Collections.emptyList();;
++      refs_ = java.util.Collections.emptyList();
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasId()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -6847,7 +10743,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -6878,13 +10774,14 @@ public final class Osmformat {
+       for (int i = 0; i < refs_.size(); i++) {
+         output.writeSInt64NoTag(refs_.get(i));
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -6936,129 +10833,121 @@ public final class Osmformat {
+         }
+         refsMemoizedSerializedSize = dataSize;
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Way parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Way prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.Way}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Way, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.WayOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.Way)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.WayOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Way.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         id_ = 0L;
+         bitField0_ = (bitField0_ & ~0x00000001);
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+         bitField0_ = (bitField0_ & ~0x00000008);
+-        refs_ = java.util.Collections.emptyList();;
++        refs_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Way getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.Way.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Way build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Way result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -7066,17 +10955,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.Way buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.Way result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Way buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Way result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Way(this);
+         int from_bitField0_ = bitField0_;
+@@ -7107,7 +10986,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Way other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Way.getDefaultInstance()) return this;
+         if (other.hasId()) {
+@@ -7119,162 +10998,142 @@ public final class Osmformat {
+             bitField0_ = (bitField0_ & ~0x00000002);
+           } else {
+             ensureKeysIsMutable();
+-            keys_.addAll(other.keys_);
+-          }
+-          
+-        }
+-        if (!other.vals_.isEmpty()) {
+-          if (vals_.isEmpty()) {
+-            vals_ = other.vals_;
+-            bitField0_ = (bitField0_ & ~0x00000004);
+-          } else {
+-            ensureValsIsMutable();
+-            vals_.addAll(other.vals_);
+-          }
+-          
+-        }
+-        if (other.hasInfo()) {
+-          mergeInfo(other.getInfo());
+-        }
+-        if (!other.refs_.isEmpty()) {
+-          if (refs_.isEmpty()) {
+-            refs_ = other.refs_;
+-            bitField0_ = (bitField0_ & ~0x00000010);
+-          } else {
+-            ensureRefsIsMutable();
+-            refs_.addAll(other.refs_);
+-          }
+-          
+-        }
+-        return this;
+-      }
+-      
+-      public final boolean isInitialized() {
+-        if (!hasId()) {
+-          
+-          return false;
+-        }
+-        return true;
+-      }
+-      
+-      public Builder mergeFrom(
+-          com.google.protobuf.CodedInputStream input,
+-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+-          throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              id_ = input.readInt64();
+-              break;
+-            }
+-            case 16: {
+-              ensureKeysIsMutable();
+-              keys_.add(input.readUInt32());
+-              break;
+-            }
+-            case 18: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addKeys(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 24: {
+-              ensureValsIsMutable();
+-              vals_.add(input.readUInt32());
+-              break;
+-            }
+-            case 26: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addVals(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 34: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder();
+-              if (hasInfo()) {
+-                subBuilder.mergeFrom(getInfo());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setInfo(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 64: {
+-              ensureRefsIsMutable();
+-              refs_.add(input.readSInt64());
+-              break;
+-            }
+-            case 66: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addRefs(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
++            keys_.addAll(other.keys_);
++          }
++          
++        }
++        if (!other.vals_.isEmpty()) {
++          if (vals_.isEmpty()) {
++            vals_ = other.vals_;
++            bitField0_ = (bitField0_ & ~0x00000004);
++          } else {
++            ensureValsIsMutable();
++            vals_.addAll(other.vals_);
++          }
++          
++        }
++        if (other.hasInfo()) {
++          mergeInfo(other.getInfo());
++        }
++        if (!other.refs_.isEmpty()) {
++          if (refs_.isEmpty()) {
++            refs_ = other.refs_;
++            bitField0_ = (bitField0_ & ~0x00000010);
++          } else {
++            ensureRefsIsMutable();
++            refs_.addAll(other.refs_);
++          }
++          
++        }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
++        return this;
++      }
++
++      public final boolean isInitialized() {
++        if (!hasId()) {
++          
++          return false;
++        }
++        return true;
++      }
++
++      public Builder mergeFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws java.io.IOException {
++        org.openstreetmap.osmosis.osmbinary.Osmformat.Way parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Way) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required int64 id = 1;
++
+       private long id_ ;
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public boolean hasId() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public long getId() {
+         return id_;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public Builder setId(long value) {
+         bitField0_ |= 0x00000001;
+         id_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public Builder clearId() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         id_ = 0L;
+         
+         return this;
+       }
+-      
+-      // repeated uint32 keys = 2 [packed = true];
+-      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+       private void ensureKeysIsMutable() {
+         if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+           keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+           bitField0_ |= 0x00000002;
+          }
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getKeysList() {
+         return java.util.Collections.unmodifiableList(keys_);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeysCount() {
+         return keys_.size();
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeys(int index) {
+         return keys_.get(index);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder setKeys(
+           int index, int value) {
+         ensureKeysIsMutable();
+@@ -7282,44 +11141,77 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addKeys(int value) {
+         ensureKeysIsMutable();
+         keys_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addAllKeys(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureKeysIsMutable();
+-        super.addAll(values, keys_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, keys_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder clearKeys() {
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+         
+         return this;
+       }
+-      
+-      // repeated uint32 vals = 3 [packed = true];
+-      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+       private void ensureValsIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+           vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+           bitField0_ |= 0x00000004;
+          }
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public java.util.List<java.lang.Integer>
+           getValsList() {
+         return java.util.Collections.unmodifiableList(vals_);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public int getValsCount() {
+         return vals_.size();
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public int getVals(int index) {
+         return vals_.get(index);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder setVals(
+           int index, int value) {
+         ensureValsIsMutable();
+@@ -7327,50 +11219,74 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder addVals(int value) {
+         ensureValsIsMutable();
+         vals_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder addAllVals(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureValsIsMutable();
+-        super.addAll(values, vals_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, vals_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder clearVals() {
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      
+-      // optional .OSMPBF.Info info = 4;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public boolean hasInfo() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+         return info_;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         info_ = value;
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder setInfo(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+         info_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (((bitField0_ & 0x00000008) == 0x00000008) &&
+             info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+@@ -7379,35 +11295,65 @@ public final class Osmformat {
+         } else {
+           info_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder clearInfo() {
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000008);
+         return this;
+       }
+-      
+-      // repeated sint64 refs = 8 [packed = true];
+-      private java.util.List<java.lang.Long> refs_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> refs_ = java.util.Collections.emptyList();
+       private void ensureRefsIsMutable() {
+         if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+           refs_ = new java.util.ArrayList<java.lang.Long>(refs_);
+           bitField0_ |= 0x00000010;
+          }
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getRefsList() {
+         return java.util.Collections.unmodifiableList(refs_);
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public int getRefsCount() {
+         return refs_.size();
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public long getRefs(int index) {
+         return refs_.get(index);
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder setRefs(
+           int index, long value) {
+         ensureRefsIsMutable();
+@@ -7415,105 +11361,452 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addRefs(long value) {
+         ensureRefsIsMutable();
+         refs_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder addAllRefs(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureRefsIsMutable();
+-        super.addAll(values, refs_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, refs_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 refs = 8 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA coded
++       * </pre>
++       */
+       public Builder clearRefs() {
+-        refs_ = java.util.Collections.emptyList();;
++        refs_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.Way)
+     }
+-    
++
+     static {
+       defaultInstance = new Way(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.Way)
+   }
+-  
+-  public interface RelationOrBuilder
+-      extends com.google.protobuf.MessageLiteOrBuilder {
+-    
+-    // required int64 id = 1;
++
++  public interface RelationOrBuilder extends
++      // @@protoc_insertion_point(interface_extends:OSMPBF.Relation)
++      com.google.protobuf.MessageLiteOrBuilder {
++
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     boolean hasId();
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     long getId();
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getKeysList();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeysCount();
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     int getKeys(int index);
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     java.util.List<java.lang.Integer> getValsList();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     int getValsCount();
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     int getVals(int index);
+-    
+-    // optional .OSMPBF.Info info = 4;
++
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     boolean hasInfo();
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo();
+-    
+-    // repeated int32 roles_sid = 8 [packed = true];
++
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     java.util.List<java.lang.Integer> getRolesSidList();
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     int getRolesSidCount();
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     int getRolesSid(int index);
+-    
+-    // repeated sint64 memids = 9 [packed = true];
++
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     java.util.List<java.lang.Long> getMemidsList();
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     int getMemidsCount();
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     long getMemids(int index);
+-    
+-    // repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];
++
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> getTypesList();
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     int getTypesCount();
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType getTypes(int index);
+   }
++  /**
++   * Protobuf type {@code OSMPBF.Relation}
++   */
+   public static final class Relation extends
+-      com.google.protobuf.GeneratedMessageLite
+-      implements RelationOrBuilder {
++      com.google.protobuf.GeneratedMessageLite implements
++      // @@protoc_insertion_point(message_implements:OSMPBF.Relation)
++      RelationOrBuilder {
+     // Use Relation.newBuilder() to construct.
+-    private Relation(Builder builder) {
++    private Relation(com.google.protobuf.GeneratedMessageLite.Builder builder) {
+       super(builder);
++      this.unknownFields = builder.getUnknownFields();
+     }
+-    private Relation(boolean noInit) {}
+-    
++    private Relation(boolean noInit) { this.unknownFields = com.google.protobuf.ByteString.EMPTY;}
++
+     private static final Relation defaultInstance;
+     public static Relation getDefaultInstance() {
+       return defaultInstance;
+     }
+-    
++
+     public Relation getDefaultInstanceForType() {
+       return defaultInstance;
+     }
+-    
++
++    private final com.google.protobuf.ByteString unknownFields;
++    private Relation(
++        com.google.protobuf.CodedInputStream input,
++        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++        throws com.google.protobuf.InvalidProtocolBufferException {
++      initFields();
++      int mutable_bitField0_ = 0;
++      com.google.protobuf.ByteString.Output unknownFieldsOutput =
++          com.google.protobuf.ByteString.newOutput();
++      com.google.protobuf.CodedOutputStream unknownFieldsCodedOutput =
++          com.google.protobuf.CodedOutputStream.newInstance(
++              unknownFieldsOutput);
++      try {
++        boolean done = false;
++        while (!done) {
++          int tag = input.readTag();
++          switch (tag) {
++            case 0:
++              done = true;
++              break;
++            default: {
++              if (!parseUnknownField(input, unknownFieldsCodedOutput,
++                                     extensionRegistry, tag)) {
++                done = true;
++              }
++              break;
++            }
++            case 8: {
++              bitField0_ |= 0x00000001;
++              id_ = input.readInt64();
++              break;
++            }
++            case 16: {
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              keys_.add(input.readUInt32());
++              break;
++            }
++            case 18: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
++                keys_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000002;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                keys_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 24: {
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              vals_.add(input.readUInt32());
++              break;
++            }
++            case 26: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000004) == 0x00000004) && input.getBytesUntilLimit() > 0) {
++                vals_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000004;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                vals_.add(input.readUInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 34: {
++              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = null;
++              if (((bitField0_ & 0x00000002) == 0x00000002)) {
++                subBuilder = info_.toBuilder();
++              }
++              info_ = input.readMessage(org.openstreetmap.osmosis.osmbinary.Osmformat.Info.PARSER, extensionRegistry);
++              if (subBuilder != null) {
++                subBuilder.mergeFrom(info_);
++                info_ = subBuilder.buildPartial();
++              }
++              bitField0_ |= 0x00000002;
++              break;
++            }
++            case 64: {
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++                rolesSid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              rolesSid_.add(input.readInt32());
++              break;
++            }
++            case 66: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000010) == 0x00000010) && input.getBytesUntilLimit() > 0) {
++                rolesSid_ = new java.util.ArrayList<java.lang.Integer>();
++                mutable_bitField0_ |= 0x00000010;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                rolesSid_.add(input.readInt32());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 72: {
++              if (!((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
++                memids_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000020;
++              }
++              memids_.add(input.readSInt64());
++              break;
++            }
++            case 74: {
++              int length = input.readRawVarint32();
++              int limit = input.pushLimit(length);
++              if (!((mutable_bitField0_ & 0x00000020) == 0x00000020) && input.getBytesUntilLimit() > 0) {
++                memids_ = new java.util.ArrayList<java.lang.Long>();
++                mutable_bitField0_ |= 0x00000020;
++              }
++              while (input.getBytesUntilLimit() > 0) {
++                memids_.add(input.readSInt64());
++              }
++              input.popLimit(limit);
++              break;
++            }
++            case 80: {
++              int rawValue = input.readEnum();
++              org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
++              if (value == null) {
++                unknownFieldsCodedOutput.writeRawVarint32(tag);
++                unknownFieldsCodedOutput.writeRawVarint32(rawValue);
++                } else {
++                if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
++                  types_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>();
++                  mutable_bitField0_ |= 0x00000040;
++                }
++                types_.add(value);
++              }
++              break;
++            }
++            case 82: {
++              int length = input.readRawVarint32();
++              int oldLimit = input.pushLimit(length);
++              while(input.getBytesUntilLimit() > 0) {
++                int rawValue = input.readEnum();
++                org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
++                if (value == null) {
++                  unknownFieldsCodedOutput.writeRawVarint32(tag);
++                  unknownFieldsCodedOutput.writeRawVarint32(rawValue);
++                  } else {
++                  if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
++                    types_ = new java.util.ArrayList<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType>();
++                    mutable_bitField0_ |= 0x00000040;
++                  }
++                  types_.add(value);
++                }
++              }
++              input.popLimit(oldLimit);
++              break;
++            }
++          }
++        }
++      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++        throw e.setUnfinishedMessage(this);
++      } catch (java.io.IOException e) {
++        throw new com.google.protobuf.InvalidProtocolBufferException(
++            e.getMessage()).setUnfinishedMessage(this);
++      } finally {
++        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
++          keys_ = java.util.Collections.unmodifiableList(keys_);
++        }
++        if (((mutable_bitField0_ & 0x00000004) == 0x00000004)) {
++          vals_ = java.util.Collections.unmodifiableList(vals_);
++        }
++        if (((mutable_bitField0_ & 0x00000010) == 0x00000010)) {
++          rolesSid_ = java.util.Collections.unmodifiableList(rolesSid_);
++        }
++        if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
++          memids_ = java.util.Collections.unmodifiableList(memids_);
++        }
++        if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
++          types_ = java.util.Collections.unmodifiableList(types_);
++        }
++        try {
++          unknownFieldsCodedOutput.flush();
++        } catch (java.io.IOException e) {
++        // Should not happen
++        } finally {
++          unknownFields = unknownFieldsOutput.toByteString();
++        }
++        makeExtensionsImmutable();
++      }
++    }
++    public static com.google.protobuf.Parser<Relation> PARSER =
++        new com.google.protobuf.AbstractParser<Relation>() {
++      public Relation parsePartialFrom(
++          com.google.protobuf.CodedInputStream input,
++          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
++          throws com.google.protobuf.InvalidProtocolBufferException {
++        return new Relation(input, extensionRegistry);
++      }
++    };
++
++    @java.lang.Override
++    public com.google.protobuf.Parser<Relation> getParserForType() {
++      return PARSER;
++    }
++
++    /**
++     * Protobuf enum {@code OSMPBF.Relation.MemberType}
++     */
+     public enum MemberType
+         implements com.google.protobuf.Internal.EnumLite {
++      /**
++       * <code>NODE = 0;</code>
++       */
+       NODE(0, 0),
++      /**
++       * <code>WAY = 1;</code>
++       */
+       WAY(1, 1),
++      /**
++       * <code>RELATION = 2;</code>
++       */
+       RELATION(2, 2),
+       ;
+-      
++
++      /**
++       * <code>NODE = 0;</code>
++       */
+       public static final int NODE_VALUE = 0;
++      /**
++       * <code>WAY = 1;</code>
++       */
+       public static final int WAY_VALUE = 1;
++      /**
++       * <code>RELATION = 2;</code>
++       */
+       public static final int RELATION_VALUE = 2;
+-      
+-      
++
++
+       public final int getNumber() { return value; }
+-      
++
+       public static MemberType valueOf(int value) {
+         switch (value) {
+           case 0: return NODE;
+@@ -7522,7 +11815,7 @@ public final class Osmformat {
+           default: return null;
+         }
+       }
+-      
++
+       public static com.google.protobuf.Internal.EnumLiteMap<MemberType>
+           internalGetValueMap() {
+         return internalValueMap;
+@@ -7534,125 +11827,212 @@ public final class Osmformat {
+                 return MemberType.valueOf(number);
+               }
+             };
+-      
++
+       private final int value;
+-      
++
+       private MemberType(int index, int value) {
+         this.value = value;
+       }
+-      
++
+       // @@protoc_insertion_point(enum_scope:OSMPBF.Relation.MemberType)
+     }
+-    
++
+     private int bitField0_;
+-    // required int64 id = 1;
+     public static final int ID_FIELD_NUMBER = 1;
+     private long id_;
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     public boolean hasId() {
+       return ((bitField0_ & 0x00000001) == 0x00000001);
+     }
++    /**
++     * <code>required int64 id = 1;</code>
++     */
+     public long getId() {
+       return id_;
+     }
+-    
+-    // repeated uint32 keys = 2 [packed = true];
++
+     public static final int KEYS_FIELD_NUMBER = 2;
+     private java.util.List<java.lang.Integer> keys_;
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getKeysList() {
+       return keys_;
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeysCount() {
+       return keys_.size();
+     }
++    /**
++     * <code>repeated uint32 keys = 2 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays.
++     * </pre>
++     */
+     public int getKeys(int index) {
+       return keys_.get(index);
+     }
+     private int keysMemoizedSerializedSize = -1;
+-    
+-    // repeated uint32 vals = 3 [packed = true];
++
+     public static final int VALS_FIELD_NUMBER = 3;
+     private java.util.List<java.lang.Integer> vals_;
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public java.util.List<java.lang.Integer>
+         getValsList() {
+       return vals_;
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public int getValsCount() {
+       return vals_.size();
+     }
++    /**
++     * <code>repeated uint32 vals = 3 [packed = true];</code>
++     */
+     public int getVals(int index) {
+       return vals_.get(index);
+     }
+     private int valsMemoizedSerializedSize = -1;
+-    
+-    // optional .OSMPBF.Info info = 4;
++
+     public static final int INFO_FIELD_NUMBER = 4;
+     private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_;
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     public boolean hasInfo() {
+       return ((bitField0_ & 0x00000002) == 0x00000002);
+     }
++    /**
++     * <code>optional .OSMPBF.Info info = 4;</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+       return info_;
+     }
+-    
+-    // repeated int32 roles_sid = 8 [packed = true];
++
+     public static final int ROLES_SID_FIELD_NUMBER = 8;
+     private java.util.List<java.lang.Integer> rolesSid_;
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     public java.util.List<java.lang.Integer>
+         getRolesSidList() {
+       return rolesSid_;
+     }
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     public int getRolesSidCount() {
+       return rolesSid_.size();
+     }
++    /**
++     * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++     *
++     * <pre>
++     * Parallel arrays
++     * </pre>
++     */
+     public int getRolesSid(int index) {
+       return rolesSid_.get(index);
+     }
+     private int rolesSidMemoizedSerializedSize = -1;
+-    
+-    // repeated sint64 memids = 9 [packed = true];
++
+     public static final int MEMIDS_FIELD_NUMBER = 9;
+     private java.util.List<java.lang.Long> memids_;
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     public java.util.List<java.lang.Long>
+         getMemidsList() {
+       return memids_;
+     }
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     public int getMemidsCount() {
+       return memids_.size();
+     }
++    /**
++     * <code>repeated sint64 memids = 9 [packed = true];</code>
++     *
++     * <pre>
++     * DELTA encoded
++     * </pre>
++     */
+     public long getMemids(int index) {
+       return memids_.get(index);
+     }
+     private int memidsMemoizedSerializedSize = -1;
+-    
+-    // repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];
++
+     public static final int TYPES_FIELD_NUMBER = 10;
+     private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> types_;
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> getTypesList() {
+       return types_;
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     public int getTypesCount() {
+       return types_.size();
+     }
++    /**
++     * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++     */
+     public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType getTypes(int index) {
+       return types_.get(index);
+     }
+     private int typesMemoizedSerializedSize;
+-    
++
+     private void initFields() {
+       id_ = 0L;
+-      keys_ = java.util.Collections.emptyList();;
+-      vals_ = java.util.Collections.emptyList();;
++      keys_ = java.util.Collections.emptyList();
++      vals_ = java.util.Collections.emptyList();
+       info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-      rolesSid_ = java.util.Collections.emptyList();;
+-      memids_ = java.util.Collections.emptyList();;
++      rolesSid_ = java.util.Collections.emptyList();
++      memids_ = java.util.Collections.emptyList();
+       types_ = java.util.Collections.emptyList();
+     }
+     private byte memoizedIsInitialized = -1;
+     public final boolean isInitialized() {
+       byte isInitialized = memoizedIsInitialized;
+-      if (isInitialized != -1) return isInitialized == 1;
+-      
++      if (isInitialized == 1) return true;
++      if (isInitialized == 0) return false;
++
+       if (!hasId()) {
+         memoizedIsInitialized = 0;
+         return false;
+@@ -7660,7 +12040,7 @@ public final class Osmformat {
+       memoizedIsInitialized = 1;
+       return true;
+     }
+-    
++
+     public void writeTo(com.google.protobuf.CodedOutputStream output)
+                         throws java.io.IOException {
+       getSerializedSize();
+@@ -7705,13 +12085,14 @@ public final class Osmformat {
+       for (int i = 0; i < types_.size(); i++) {
+         output.writeEnumNoTag(types_.get(i).getNumber());
+       }
++      output.writeRawBytes(unknownFields);
+     }
+-    
++
+     private int memoizedSerializedSize = -1;
+     public int getSerializedSize() {
+       int size = memoizedSerializedSize;
+       if (size != -1) return size;
+-    
++
+       size = 0;
+       if (((bitField0_ & 0x00000001) == 0x00000001)) {
+         size += com.google.protobuf.CodedOutputStream
+@@ -7789,133 +12170,125 @@ public final class Osmformat {
+             .computeRawVarint32Size(dataSize);
+         }typesMemoizedSerializedSize = dataSize;
+       }
++      size += unknownFields.size();
+       memoizedSerializedSize = size;
+       return size;
+     }
+-    
++
+     private static final long serialVersionUID = 0L;
+     @java.lang.Override
+     protected java.lang.Object writeReplace()
+         throws java.io.ObjectStreamException {
+       return super.writeReplace();
+     }
+-    
++
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         com.google.protobuf.ByteString data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         com.google.protobuf.ByteString data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(byte[] data)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data).buildParsed();
++      return PARSER.parseFrom(data);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         byte[] data,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws com.google.protobuf.InvalidProtocolBufferException {
+-      return newBuilder().mergeFrom(data, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(data, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseDelimitedFrom(java.io.InputStream input)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseDelimitedFrom(
+         java.io.InputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      Builder builder = newBuilder();
+-      if (builder.mergeDelimitedFrom(input, extensionRegistry)) {
+-        return builder.buildParsed();
+-      } else {
+-        return null;
+-      }
++      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         com.google.protobuf.CodedInputStream input)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input).buildParsed();
++      return PARSER.parseFrom(input);
+     }
+     public static org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parseFrom(
+         com.google.protobuf.CodedInputStream input,
+         com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+         throws java.io.IOException {
+-      return newBuilder().mergeFrom(input, extensionRegistry)
+-               .buildParsed();
++      return PARSER.parseFrom(input, extensionRegistry);
+     }
+-    
++
+     public static Builder newBuilder() { return Builder.create(); }
+     public Builder newBuilderForType() { return newBuilder(); }
+     public static Builder newBuilder(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation prototype) {
+       return newBuilder().mergeFrom(prototype);
+     }
+     public Builder toBuilder() { return newBuilder(this); }
+-    
++
++    /**
++     * Protobuf type {@code OSMPBF.Relation}
++     */
+     public static final class Builder extends
+         com.google.protobuf.GeneratedMessageLite.Builder<
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Relation, Builder>
+-        implements org.openstreetmap.osmosis.osmbinary.Osmformat.RelationOrBuilder {
++        implements
++        // @@protoc_insertion_point(builder_implements:OSMPBF.Relation)
++        org.openstreetmap.osmosis.osmbinary.Osmformat.RelationOrBuilder {
+       // Construct using org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.newBuilder()
+       private Builder() {
+         maybeForceBuilderInitialization();
+       }
+-      
++
+       private void maybeForceBuilderInitialization() {
+       }
+       private static Builder create() {
+         return new Builder();
+       }
+-      
++
+       public Builder clear() {
+         super.clear();
+         id_ = 0L;
+         bitField0_ = (bitField0_ & ~0x00000001);
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+         bitField0_ = (bitField0_ & ~0x00000008);
+-        rolesSid_ = java.util.Collections.emptyList();;
++        rolesSid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+-        memids_ = java.util.Collections.emptyList();;
++        memids_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000020);
+         types_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000040);
+         return this;
+       }
+-      
++
+       public Builder clone() {
+         return create().mergeFrom(buildPartial());
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation getDefaultInstanceForType() {
+         return org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.getDefaultInstance();
+       }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation build() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Relation result = buildPartial();
+         if (!result.isInitialized()) {
+@@ -7923,17 +12296,7 @@ public final class Osmformat {
+         }
+         return result;
+       }
+-      
+-      private org.openstreetmap.osmosis.osmbinary.Osmformat.Relation buildParsed()
+-          throws com.google.protobuf.InvalidProtocolBufferException {
+-        org.openstreetmap.osmosis.osmbinary.Osmformat.Relation result = buildPartial();
+-        if (!result.isInitialized()) {
+-          throw newUninitializedMessageException(
+-            result).asInvalidProtocolBufferException();
+-        }
+-        return result;
+-      }
+-      
++
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation buildPartial() {
+         org.openstreetmap.osmosis.osmbinary.Osmformat.Relation result = new org.openstreetmap.osmosis.osmbinary.Osmformat.Relation(this);
+         int from_bitField0_ = bitField0_;
+@@ -7974,7 +12337,7 @@ public final class Osmformat {
+         result.bitField0_ = to_bitField0_;
+         return result;
+       }
+-      
++
+       public Builder mergeFrom(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation other) {
+         if (other == org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.getDefaultInstance()) return this;
+         if (other.hasId()) {
+@@ -8033,9 +12396,11 @@ public final class Osmformat {
+           }
+           
+         }
++        setUnknownFields(
++            getUnknownFields().concat(other.unknownFields));
+         return this;
+       }
+-      
++
+       public final boolean isInitialized() {
+         if (!hasId()) {
+           
+@@ -8043,160 +12408,103 @@ public final class Osmformat {
+         }
+         return true;
+       }
+-      
++
+       public Builder mergeFrom(
+           com.google.protobuf.CodedInputStream input,
+           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+           throws java.io.IOException {
+-        while (true) {
+-          int tag = input.readTag();
+-          switch (tag) {
+-            case 0:
+-              
+-              return this;
+-            default: {
+-              if (!parseUnknownField(input, extensionRegistry, tag)) {
+-                
+-                return this;
+-              }
+-              break;
+-            }
+-            case 8: {
+-              bitField0_ |= 0x00000001;
+-              id_ = input.readInt64();
+-              break;
+-            }
+-            case 16: {
+-              ensureKeysIsMutable();
+-              keys_.add(input.readUInt32());
+-              break;
+-            }
+-            case 18: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addKeys(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 24: {
+-              ensureValsIsMutable();
+-              vals_.add(input.readUInt32());
+-              break;
+-            }
+-            case 26: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addVals(input.readUInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 34: {
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder subBuilder = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.newBuilder();
+-              if (hasInfo()) {
+-                subBuilder.mergeFrom(getInfo());
+-              }
+-              input.readMessage(subBuilder, extensionRegistry);
+-              setInfo(subBuilder.buildPartial());
+-              break;
+-            }
+-            case 64: {
+-              ensureRolesSidIsMutable();
+-              rolesSid_.add(input.readInt32());
+-              break;
+-            }
+-            case 66: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addRolesSid(input.readInt32());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 72: {
+-              ensureMemidsIsMutable();
+-              memids_.add(input.readSInt64());
+-              break;
+-            }
+-            case 74: {
+-              int length = input.readRawVarint32();
+-              int limit = input.pushLimit(length);
+-              while (input.getBytesUntilLimit() > 0) {
+-                addMemids(input.readSInt64());
+-              }
+-              input.popLimit(limit);
+-              break;
+-            }
+-            case 80: {
+-              int rawValue = input.readEnum();
+-              org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
+-              if (value != null) {
+-                addTypes(value);
+-              }
+-              break;
+-            }
+-            case 82: {
+-              int length = input.readRawVarint32();
+-              int oldLimit = input.pushLimit(length);
+-              while(input.getBytesUntilLimit() > 0) {
+-                int rawValue = input.readEnum();
+-                org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value = org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType.valueOf(rawValue);
+-                if (value != null) {
+-                  addTypes(value);
+-                }
+-              }
+-              input.popLimit(oldLimit);
+-              break;
+-            }
++        org.openstreetmap.osmosis.osmbinary.Osmformat.Relation parsedMessage = null;
++        try {
++          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
++        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
++          parsedMessage = (org.openstreetmap.osmosis.osmbinary.Osmformat.Relation) e.getUnfinishedMessage();
++          throw e;
++        } finally {
++          if (parsedMessage != null) {
++            mergeFrom(parsedMessage);
+           }
+         }
++        return this;
+       }
+-      
+       private int bitField0_;
+-      
+-      // required int64 id = 1;
++
+       private long id_ ;
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public boolean hasId() {
+         return ((bitField0_ & 0x00000001) == 0x00000001);
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public long getId() {
+         return id_;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public Builder setId(long value) {
+         bitField0_ |= 0x00000001;
+         id_ = value;
+         
+         return this;
+       }
++      /**
++       * <code>required int64 id = 1;</code>
++       */
+       public Builder clearId() {
+         bitField0_ = (bitField0_ & ~0x00000001);
+         id_ = 0L;
+         
+         return this;
+       }
+-      
+-      // repeated uint32 keys = 2 [packed = true];
+-      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> keys_ = java.util.Collections.emptyList();
+       private void ensureKeysIsMutable() {
+         if (!((bitField0_ & 0x00000002) == 0x00000002)) {
+           keys_ = new java.util.ArrayList<java.lang.Integer>(keys_);
+           bitField0_ |= 0x00000002;
+          }
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getKeysList() {
+         return java.util.Collections.unmodifiableList(keys_);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeysCount() {
+         return keys_.size();
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public int getKeys(int index) {
+         return keys_.get(index);
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder setKeys(
+           int index, int value) {
+         ensureKeysIsMutable();
+@@ -8204,44 +12512,77 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addKeys(int value) {
+         ensureKeysIsMutable();
+         keys_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder addAllKeys(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureKeysIsMutable();
+-        super.addAll(values, keys_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, keys_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 keys = 2 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays.
++       * </pre>
++       */
+       public Builder clearKeys() {
+-        keys_ = java.util.Collections.emptyList();;
++        keys_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000002);
+         
+         return this;
+       }
+-      
+-      // repeated uint32 vals = 3 [packed = true];
+-      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> vals_ = java.util.Collections.emptyList();
+       private void ensureValsIsMutable() {
+         if (!((bitField0_ & 0x00000004) == 0x00000004)) {
+           vals_ = new java.util.ArrayList<java.lang.Integer>(vals_);
+           bitField0_ |= 0x00000004;
+          }
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public java.util.List<java.lang.Integer>
+           getValsList() {
+         return java.util.Collections.unmodifiableList(vals_);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public int getValsCount() {
+         return vals_.size();
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public int getVals(int index) {
+         return vals_.get(index);
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder setVals(
+           int index, int value) {
+         ensureValsIsMutable();
+@@ -8249,50 +12590,74 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder addVals(int value) {
+         ensureValsIsMutable();
+         vals_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder addAllVals(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureValsIsMutable();
+-        super.addAll(values, vals_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, vals_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated uint32 vals = 3 [packed = true];</code>
++       */
+       public Builder clearVals() {
+-        vals_ = java.util.Collections.emptyList();;
++        vals_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000004);
+         
+         return this;
+       }
+-      
+-      // optional .OSMPBF.Info info = 4;
++
+       private org.openstreetmap.osmosis.osmbinary.Osmformat.Info info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public boolean hasInfo() {
+         return ((bitField0_ & 0x00000008) == 0x00000008);
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Info getInfo() {
+         return info_;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder setInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (value == null) {
+           throw new NullPointerException();
+         }
+         info_ = value;
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder setInfo(
+           org.openstreetmap.osmosis.osmbinary.Osmformat.Info.Builder builderForValue) {
+         info_ = builderForValue.build();
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder mergeInfo(org.openstreetmap.osmosis.osmbinary.Osmformat.Info value) {
+         if (((bitField0_ & 0x00000008) == 0x00000008) &&
+             info_ != org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance()) {
+@@ -8301,35 +12666,65 @@ public final class Osmformat {
+         } else {
+           info_ = value;
+         }
+-        
++
+         bitField0_ |= 0x00000008;
+         return this;
+       }
++      /**
++       * <code>optional .OSMPBF.Info info = 4;</code>
++       */
+       public Builder clearInfo() {
+         info_ = org.openstreetmap.osmosis.osmbinary.Osmformat.Info.getDefaultInstance();
+-        
++
+         bitField0_ = (bitField0_ & ~0x00000008);
+         return this;
+       }
+-      
+-      // repeated int32 roles_sid = 8 [packed = true];
+-      private java.util.List<java.lang.Integer> rolesSid_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Integer> rolesSid_ = java.util.Collections.emptyList();
+       private void ensureRolesSidIsMutable() {
+         if (!((bitField0_ & 0x00000010) == 0x00000010)) {
+           rolesSid_ = new java.util.ArrayList<java.lang.Integer>(rolesSid_);
+           bitField0_ |= 0x00000010;
+          }
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public java.util.List<java.lang.Integer>
+           getRolesSidList() {
+         return java.util.Collections.unmodifiableList(rolesSid_);
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public int getRolesSidCount() {
+         return rolesSid_.size();
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public int getRolesSid(int index) {
+         return rolesSid_.get(index);
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public Builder setRolesSid(
+           int index, int value) {
+         ensureRolesSidIsMutable();
+@@ -8337,44 +12732,93 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public Builder addRolesSid(int value) {
+         ensureRolesSidIsMutable();
+         rolesSid_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public Builder addAllRolesSid(
+           java.lang.Iterable<? extends java.lang.Integer> values) {
+         ensureRolesSidIsMutable();
+-        super.addAll(values, rolesSid_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, rolesSid_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated int32 roles_sid = 8 [packed = true];</code>
++       *
++       * <pre>
++       * Parallel arrays
++       * </pre>
++       */
+       public Builder clearRolesSid() {
+-        rolesSid_ = java.util.Collections.emptyList();;
++        rolesSid_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000010);
+         
+         return this;
+       }
+-      
+-      // repeated sint64 memids = 9 [packed = true];
+-      private java.util.List<java.lang.Long> memids_ = java.util.Collections.emptyList();;
++
++      private java.util.List<java.lang.Long> memids_ = java.util.Collections.emptyList();
+       private void ensureMemidsIsMutable() {
+         if (!((bitField0_ & 0x00000020) == 0x00000020)) {
+           memids_ = new java.util.ArrayList<java.lang.Long>(memids_);
+           bitField0_ |= 0x00000020;
+          }
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public java.util.List<java.lang.Long>
+           getMemidsList() {
+         return java.util.Collections.unmodifiableList(memids_);
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public int getMemidsCount() {
+         return memids_.size();
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public long getMemids(int index) {
+         return memids_.get(index);
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public Builder setMemids(
+           int index, long value) {
+         ensureMemidsIsMutable();
+@@ -8382,27 +12826,48 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public Builder addMemids(long value) {
+         ensureMemidsIsMutable();
+         memids_.add(value);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public Builder addAllMemids(
+           java.lang.Iterable<? extends java.lang.Long> values) {
+         ensureMemidsIsMutable();
+-        super.addAll(values, memids_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, memids_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated sint64 memids = 9 [packed = true];</code>
++       *
++       * <pre>
++       * DELTA encoded
++       * </pre>
++       */
+       public Builder clearMemids() {
+-        memids_ = java.util.Collections.emptyList();;
++        memids_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000020);
+         
+         return this;
+       }
+-      
+-      // repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];
++
+       private java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> types_ =
+         java.util.Collections.emptyList();
+       private void ensureTypesIsMutable() {
+@@ -8411,15 +12876,27 @@ public final class Osmformat {
+           bitField0_ |= 0x00000040;
+         }
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public java.util.List<org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> getTypesList() {
+         return java.util.Collections.unmodifiableList(types_);
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public int getTypesCount() {
+         return types_.size();
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType getTypes(int index) {
+         return types_.get(index);
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public Builder setTypes(
+           int index, org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
+         if (value == null) {
+@@ -8430,6 +12907,9 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public Builder addTypes(org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType value) {
+         if (value == null) {
+           throw new NullPointerException();
+@@ -8439,34 +12919,41 @@ public final class Osmformat {
+         
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public Builder addAllTypes(
+           java.lang.Iterable<? extends org.openstreetmap.osmosis.osmbinary.Osmformat.Relation.MemberType> values) {
+         ensureTypesIsMutable();
+-        super.addAll(values, types_);
++        com.google.protobuf.AbstractMessageLite.Builder.addAll(
++            values, types_);
+         
+         return this;
+       }
++      /**
++       * <code>repeated .OSMPBF.Relation.MemberType types = 10 [packed = true];</code>
++       */
+       public Builder clearTypes() {
+         types_ = java.util.Collections.emptyList();
+         bitField0_ = (bitField0_ & ~0x00000040);
+         
+         return this;
+       }
+-      
++
+       // @@protoc_insertion_point(builder_scope:OSMPBF.Relation)
+     }
+-    
++
+     static {
+       defaultInstance = new Relation(true);
+       defaultInstance.initFields();
+     }
+-    
++
+     // @@protoc_insertion_point(class_scope:OSMPBF.Relation)
+   }
+-  
+-  
++
++
+   static {
+   }
+-  
++
+   // @@protoc_insertion_point(outer_class_scope)
+ }
diff --git a/debian/patches/series b/debian/patches/series
index d26f8c3..55293ed 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -2,6 +2,7 @@
 02-fix_plexus.patch
 03-local-dependencies.patch
 04-osmosis-version.patch
+05-protobuf-2.6.0.patch
 0001-Modify-the-pgsnapshot-load-script-to-more-sensible-d.patch
 0001-Use-ALTER-TABLE-.-CLUSTER-ON-statements-to-set-what-.patch
 0001-Disable-synchronous_commit-for-pgsnapshot-loading.patch

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/osmosis.git



More information about the Pkg-grass-devel mailing list