public Builder clearGroupIndex() {
        bitField0_ = (bitField0_ & ~0x00000004);
        groupIndex_ = 0;
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbFilter)
    }
    
    static {
      defaultInstance = new PbFilter(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbFilter)
  }
  
  public interface PbShapeOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional int64 tag = 1;
    boolean hasTag();
    long getTag();
    
    // required .box2d.PbShapeType type = 2;
    boolean hasType();
    org.box2d.proto.Box2D.PbShapeType getType();
    
    // optional .box2d.PbVec2 center = 10;
    boolean hasCenter();
    org.box2d.proto.Box2D.PbVec2 getCenter();
    org.box2d.proto.Box2D.PbVec2OrBuilder getCenterOrBuilder();
    
    // optional float radius = 11;
    boolean hasRadius();
    float getRadius();
    
    // repeated .box2d.PbVec2 points = 20;
    java.util.List<org.box2d.proto.Box2D.PbVec2> 
        getPointsList();
    org.box2d.proto.Box2D.PbVec2 getPoints(int index);
    int getPointsCount();
    java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
        getPointsOrBuilderList();
    org.box2d.proto.Box2D.PbVec2OrBuilder getPointsOrBuilder(
        int index);
    
    // repeated .box2d.PbVec2 normals = 21;
    java.util.List<org.box2d.proto.Box2D.PbVec2> 
        getNormalsList();
    org.box2d.proto.Box2D.PbVec2 getNormals(int index);
    int getNormalsCount();
    java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
        getNormalsOrBuilderList();
    org.box2d.proto.Box2D.PbVec2OrBuilder getNormalsOrBuilder(
        int index);
    
    // optional .box2d.PbVec2 centroid = 22;
    boolean hasCentroid();
    org.box2d.proto.Box2D.PbVec2 getCentroid();
    org.box2d.proto.Box2D.PbVec2OrBuilder getCentroidOrBuilder();
  }
  public static final class PbShape extends
      com.google.protobuf.GeneratedMessage
      implements PbShapeOrBuilder {
    // Use PbShape.newBuilder() to construct.
    private PbShape(Builder builder) {
      super(builder);
    }
    private PbShape(boolean noInit) {}
    
    private static final PbShape defaultInstance;
    public static PbShape getDefaultInstance() {
      return defaultInstance;
    }
    
    public PbShape getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbShape_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbShape_fieldAccessorTable;
    }
    
    private int bitField0_;
    // optional int64 tag = 1;
    public static final int TAG_FIELD_NUMBER = 1;
    private long tag_;
    public boolean hasTag() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public long getTag() {
      return tag_;
    }
    
    // required .box2d.PbShapeType type = 2;
    public static final int TYPE_FIELD_NUMBER = 2;
    private org.box2d.proto.Box2D.PbShapeType type_;
    public boolean hasType() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public org.box2d.proto.Box2D.PbShapeType getType() {
      return type_;
    }
    
    // optional .box2d.PbVec2 center = 10;
    public static final int CENTER_FIELD_NUMBER = 10;
    private org.box2d.proto.Box2D.PbVec2 center_;
    public boolean hasCenter() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public org.box2d.proto.Box2D.PbVec2 getCenter() {
      return center_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getCenterOrBuilder() {
      return center_;
    }
    
    // optional float radius = 11;
    public static final int RADIUS_FIELD_NUMBER = 11;
    private float radius_;
    public boolean hasRadius() {
      return ((bitField0_ & 0x00000008) == 0x00000008);
    }
    public float getRadius() {
      return radius_;
    }
    
    // repeated .box2d.PbVec2 points = 20;
    public static final int POINTS_FIELD_NUMBER = 20;
    private java.util.List<org.box2d.proto.Box2D.PbVec2> points_;
    public java.util.List<org.box2d.proto.Box2D.PbVec2> getPointsList() {
      return points_;
    }
    public java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
        getPointsOrBuilderList() {
      return points_;
    }
    public int getPointsCount() {
      return points_.size();
    }
    public org.box2d.proto.Box2D.PbVec2 getPoints(int index) {
      return points_.get(index);
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getPointsOrBuilder(
        int index) {
      return points_.get(index);
    }
    
    // repeated .box2d.PbVec2 normals = 21;
    public static final int NORMALS_FIELD_NUMBER = 21;
    private java.util.List<org.box2d.proto.Box2D.PbVec2> normals_;
    public java.util.List<org.box2d.proto.Box2D.PbVec2> getNormalsList() {
      return normals_;
    }
    public java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
        getNormalsOrBuilderList() {
      return normals_;
    }
    public int getNormalsCount() {
      return normals_.size();
    }
    public org.box2d.proto.Box2D.PbVec2 getNormals(int index) {
      return normals_.get(index);
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getNormalsOrBuilder(
        int index) {
      return normals_.get(index);
    }
    
    // optional .box2d.PbVec2 centroid = 22;
    public static final int CENTROID_FIELD_NUMBER = 22;
    private org.box2d.proto.Box2D.PbVec2 centroid_;
    public boolean hasCentroid() {
      return ((bitField0_ & 0x00000010) == 0x00000010);
    }
    public org.box2d.proto.Box2D.PbVec2 getCentroid() {
      return centroid_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getCentroidOrBuilder() {
      return centroid_;
    }
    
    private void initFields() {
      tag_ = 0L;
      type_ = org.box2d.proto.Box2D.PbShapeType.CIRCLE;
      center_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      radius_ = 0F;
      points_ = java.util.Collections.emptyList();
      normals_ = java.util.Collections.emptyList();
      centroid_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasType()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasCenter()) {
        if (!getCenter().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getPointsCount(); i++) {
        if (!getPoints(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getNormalsCount(); i++) {
        if (!getNormals(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasCentroid()) {
        if (!getCentroid().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeInt64(1, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeEnum(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeMessage(10, center_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeFloat(11, radius_);
      }
      for (int i = 0; i < points_.size(); i++) {
        output.writeMessage(20, points_.get(i));
      }
      for (int i = 0; i < normals_.size(); i++) {
        output.writeMessage(21, normals_.get(i));
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeMessage(22, centroid_);
      }
      getUnknownFields().writeTo(output);
    }
    
    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, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(10, center_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(11, radius_);
      }
      for (int i = 0; i < points_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(20, points_.get(i));
      }
      for (int i = 0; i < normals_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(21, normals_.get(i));
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(22, centroid_);
      }
      size += getUnknownFields().getSerializedSize();
      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.box2d.proto.Box2D.PbShape parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.box2d.proto.Box2D.PbShape 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;
      }
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbShape parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.box2d.proto.Box2D.PbShape prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements org.box2d.proto.Box2D.PbShapeOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbShape_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbShape_fieldAccessorTable;
      }
      
      // Construct using org.box2d.proto.Box2D.PbShape.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getCenterFieldBuilder();
          getPointsFieldBuilder();
          getNormalsFieldBuilder();
          getCentroidFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        tag_ = 0L;
        bitField0_ = (bitField0_ & ~0x00000001);
        type_ = org.box2d.proto.Box2D.PbShapeType.CIRCLE;
        bitField0_ = (bitField0_ & ~0x00000002);
        if (centerBuilder_ == null) {
          center_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          centerBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        radius_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000008);
        if (pointsBuilder_ == null) {
          points_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000010);
        } else {
          pointsBuilder_.clear();
        }
        if (normalsBuilder_ == null) {
          normals_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000020);
        } else {
          normalsBuilder_.clear();
        }
        if (centroidBuilder_ == null) {
          centroid_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          centroidBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.box2d.proto.Box2D.PbShape.getDescriptor();
      }
      
      public org.box2d.proto.Box2D.PbShape getDefaultInstanceForType() {
        return org.box2d.proto.Box2D.PbShape.getDefaultInstance();
      }
      
      public org.box2d.proto.Box2D.PbShape build() {
        org.box2d.proto.Box2D.PbShape result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private org.box2d.proto.Box2D.PbShape buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        org.box2d.proto.Box2D.PbShape result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public org.box2d.proto.Box2D.PbShape buildPartial() {
        org.box2d.proto.Box2D.PbShape result = new org.box2d.proto.Box2D.PbShape(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.tag_ = tag_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.type_ = type_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        if (centerBuilder_ == null) {
          result.center_ = center_;
        } else {
          result.center_ = centerBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
          to_bitField0_ |= 0x00000008;
        }
        result.radius_ = radius_;
        if (pointsBuilder_ == null) {
          if (((bitField0_ & 0x00000010) == 0x00000010)) {
            points_ = java.util.Collections.unmodifiableList(points_);
            bitField0_ = (bitField0_ & ~0x00000010);
          }
          result.points_ = points_;
        } else {
          result.points_ = pointsBuilder_.build();
        }
        if (normalsBuilder_ == null) {
          if (((bitField0_ & 0x00000020) == 0x00000020)) {
            normals_ = java.util.Collections.unmodifiableList(normals_);
            bitField0_ = (bitField0_ & ~0x00000020);
          }
          result.normals_ = normals_;
        } else {
          result.normals_ = normalsBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
          to_bitField0_ |= 0x00000010;
        }
        if (centroidBuilder_ == null) {
          result.centroid_ = centroid_;
        } else {
          result.centroid_ = centroidBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.box2d.proto.Box2D.PbShape) {
          return mergeFrom((org.box2d.proto.Box2D.PbShape)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.box2d.proto.Box2D.PbShape other) {
        if (other == org.box2d.proto.Box2D.PbShape.getDefaultInstance()) return this;
        if (other.hasTag()) {
          setTag(other.getTag());
        }
        if (other.hasType()) {
          setType(other.getType());
        }
        if (other.hasCenter()) {
          mergeCenter(other.getCenter());
        }
        if (other.hasRadius()) {
          setRadius(other.getRadius());
        }
        if (pointsBuilder_ == null) {
          if (!other.points_.isEmpty()) {
            if (points_.isEmpty()) {
              points_ = other.points_;
              bitField0_ = (bitField0_ & ~0x00000010);
            } else {
              ensurePointsIsMutable();
              points_.addAll(other.points_);
            }
            onChanged();
          }
        } else {
          if (!other.points_.isEmpty()) {
            if (pointsBuilder_.isEmpty()) {
              pointsBuilder_.dispose();
              pointsBuilder_ = null;
              points_ = other.points_;
              bitField0_ = (bitField0_ & ~0x00000010);
              pointsBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getPointsFieldBuilder() : null;
            } else {
              pointsBuilder_.addAllMessages(other.points_);
            }
          }
        }
        if (normalsBuilder_ == null) {
          if (!other.normals_.isEmpty()) {
            if (normals_.isEmpty()) {
              normals_ = other.normals_;
              bitField0_ = (bitField0_ & ~0x00000020);
            } else {
              ensureNormalsIsMutable();
              normals_.addAll(other.normals_);
            }
            onChanged();
          }
        } else {
          if (!other.normals_.isEmpty()) {
            if (normalsBuilder_.isEmpty()) {
              normalsBuilder_.dispose();
              normalsBuilder_ = null;
              normals_ = other.normals_;
              bitField0_ = (bitField0_ & ~0x00000020);
              normalsBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getNormalsFieldBuilder() : null;
            } else {
              normalsBuilder_.addAllMessages(other.normals_);
            }
          }
        }
        if (other.hasCentroid()) {
          mergeCentroid(other.getCentroid());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasType()) {
          
          return false;
        }
        if (hasCenter()) {
          if (!getCenter().isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getPointsCount(); i++) {
          if (!getPoints(i).isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getNormalsCount(); i++) {
          if (!getNormals(i).isInitialized()) {
            
            return false;
          }
        }
        if (hasCentroid()) {
          if (!getCentroid().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              bitField0_ |= 0x00000001;
              tag_ = input.readInt64();
              break;
            }
            case 16: {
              int rawValue = input.readEnum();
              org.box2d.proto.Box2D.PbShapeType value = org.box2d.proto.Box2D.PbShapeType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(2, rawValue);
              } else {
                bitField0_ |= 0x00000002;
                type_ = value;
              }
              break;
            }
            case 82: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasCenter()) {
                subBuilder.mergeFrom(getCenter());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setCenter(subBuilder.buildPartial());
              break;
            }
            case 93: {
              bitField0_ |= 0x00000008;
              radius_ = input.readFloat();
              break;
            }
            case 162: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addPoints(subBuilder.buildPartial());
              break;
            }
            case 170: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addNormals(subBuilder.buildPartial());
              break;
            }
            case 178: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasCentroid()) {
                subBuilder.mergeFrom(getCentroid());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setCentroid(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // optional int64 tag = 1;
      private long tag_ ;
      public boolean hasTag() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public long getTag() {
        return tag_;
      }
      public Builder setTag(long value) {
        bitField0_ |= 0x00000001;
        tag_ = value;
        onChanged();
        return this;
      }
      public Builder clearTag() {
        bitField0_ = (bitField0_ & ~0x00000001);
        tag_ = 0L;
        onChanged();
        return this;
      }
      
      // required .box2d.PbShapeType type = 2;
      private org.box2d.proto.Box2D.PbShapeType type_ = org.box2d.proto.Box2D.PbShapeType.CIRCLE;
      public boolean hasType() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public org.box2d.proto.Box2D.PbShapeType getType() {
        return type_;
      }
      public Builder setType(org.box2d.proto.Box2D.PbShapeType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        bitField0_ |= 0x00000002;
        type_ = value;
        onChanged();
        return this;
      }
      public Builder clearType() {
        bitField0_ = (bitField0_ & ~0x00000002);
        type_ = org.box2d.proto.Box2D.PbShapeType.CIRCLE;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 center = 10;
      private org.box2d.proto.Box2D.PbVec2 center_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> centerBuilder_;
      public boolean hasCenter() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public org.box2d.proto.Box2D.PbVec2 getCenter() {
        if (centerBuilder_ == null) {
          return center_;
        } else {
          return centerBuilder_.getMessage();
        }
      }
      public Builder setCenter(org.box2d.proto.Box2D.PbVec2 value) {
        if (centerBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          center_ = value;
          onChanged();
        } else {
          centerBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder setCenter(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (centerBuilder_ == null) {
          center_ = builderForValue.build();
          onChanged();
        } else {
          centerBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder mergeCenter(org.box2d.proto.Box2D.PbVec2 value) {
        if (centerBuilder_ == null) {
          if (((bitField0_ & 0x00000004) == 0x00000004) &&
              center_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            center_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(center_).mergeFrom(value).buildPartial();
          } else {
            center_ = value;
          }
          onChanged();
        } else {
          centerBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder clearCenter() {
        if (centerBuilder_ == null) {
          center_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          centerBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getCenterBuilder() {
        bitField0_ |= 0x00000004;
        onChanged();
        return getCenterFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getCenterOrBuilder() {
        if (centerBuilder_ != null) {
          return centerBuilder_.getMessageOrBuilder();
        } else {
          return center_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getCenterFieldBuilder() {
        if (centerBuilder_ == null) {
          centerBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  center_,
                  getParentForChildren(),
                  isClean());
          center_ = null;
        }
        return centerBuilder_;
      }
      
      // optional float radius = 11;
      private float radius_ ;
      public boolean hasRadius() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public float getRadius() {
        return radius_;
      }
      public Builder setRadius(float value) {
        bitField0_ |= 0x00000008;
        radius_ = value;
        onChanged();
        return this;
      }
      public Builder clearRadius() {
        bitField0_ = (bitField0_ & ~0x00000008);
        radius_ = 0F;
        onChanged();
        return this;
      }
      
      // repeated .box2d.PbVec2 points = 20;
      private java.util.List<org.box2d.proto.Box2D.PbVec2> points_ =
        java.util.Collections.emptyList();
      private void ensurePointsIsMutable() {
        if (!((bitField0_ & 0x00000010) == 0x00000010)) {
          points_ = new java.util.ArrayList<org.box2d.proto.Box2D.PbVec2>(points_);
          bitField0_ |= 0x00000010;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> pointsBuilder_;
      
      public java.util.List<org.box2d.proto.Box2D.PbVec2> getPointsList() {
        if (pointsBuilder_ == null) {
          return java.util.Collections.unmodifiableList(points_);
        } else {
          return pointsBuilder_.getMessageList();
        }
      }
      public int getPointsCount() {
        if (pointsBuilder_ == null) {
          return points_.size();
        } else {
          return pointsBuilder_.getCount();
        }
      }
      public org.box2d.proto.Box2D.PbVec2 getPoints(int index) {
        if (pointsBuilder_ == null) {
          return points_.get(index);
        } else {
          return pointsBuilder_.getMessage(index);
        }
      }
      public Builder setPoints(
          int index, org.box2d.proto.Box2D.PbVec2 value) {
        if (pointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensurePointsIsMutable();
          points_.set(index, value);
          onChanged();
        } else {
          pointsBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setPoints(
          int index, org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (pointsBuilder_ == null) {
          ensurePointsIsMutable();
          points_.set(index, builderForValue.build());
          onChanged();
        } else {
          pointsBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addPoints(org.box2d.proto.Box2D.PbVec2 value) {
        if (pointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensurePointsIsMutable();
          points_.add(value);
          onChanged();
        } else {
          pointsBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addPoints(
          int index, org.box2d.proto.Box2D.PbVec2 value) {
        if (pointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensurePointsIsMutable();
          points_.add(index, value);
          onChanged();
        } else {
          pointsBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addPoints(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (pointsBuilder_ == null) {
          ensurePointsIsMutable();
          points_.add(builderForValue.build());
          onChanged();
        } else {
          pointsBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addPoints(
          int index, org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (pointsBuilder_ == null) {
          ensurePointsIsMutable();
          points_.add(index, builderForValue.build());
          onChanged();
        } else {
          pointsBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllPoints(
          java.lang.Iterable<? extends org.box2d.proto.Box2D.PbVec2> values) {
        if (pointsBuilder_ == null) {
          ensurePointsIsMutable();
          super.addAll(values, points_);
          onChanged();
        } else {
          pointsBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearPoints() {
        if (pointsBuilder_ == null) {
          points_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000010);
          onChanged();
        } else {
          pointsBuilder_.clear();
        }
        return this;
      }
      public Builder removePoints(int index) {
        if (pointsBuilder_ == null) {
          ensurePointsIsMutable();
          points_.remove(index);
          onChanged();
        } else {
          pointsBuilder_.remove(index);
        }
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getPointsBuilder(
          int index) {
        return getPointsFieldBuilder().getBuilder(index);
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getPointsOrBuilder(
          int index) {
        if (pointsBuilder_ == null) {
          return points_.get(index);  } else {
          return pointsBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
           getPointsOrBuilderList() {
        if (pointsBuilder_ != null) {
          return pointsBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(points_);
        }
      }
      public org.box2d.proto.Box2D.PbVec2.Builder addPointsBuilder() {
        return getPointsFieldBuilder().addBuilder(
            org.box2d.proto.Box2D.PbVec2.getDefaultInstance());
      }
      public org.box2d.proto.Box2D.PbVec2.Builder addPointsBuilder(
          int index) {
        return getPointsFieldBuilder().addBuilder(
            index, org.box2d.proto.Box2D.PbVec2.getDefaultInstance());
      }
      public java.util.List<org.box2d.proto.Box2D.PbVec2.Builder> 
           getPointsBuilderList() {
        return getPointsFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getPointsFieldBuilder() {
        if (pointsBuilder_ == null) {
          pointsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  points_,
                  ((bitField0_ & 0x00000010) == 0x00000010),
                  getParentForChildren(),
                  isClean());
          points_ = null;
        }
        return pointsBuilder_;
      }
      
      // repeated .box2d.PbVec2 normals = 21;
      private java.util.List<org.box2d.proto.Box2D.PbVec2> normals_ =
        java.util.Collections.emptyList();
      private void ensureNormalsIsMutable() {
        if (!((bitField0_ & 0x00000020) == 0x00000020)) {
          normals_ = new java.util.ArrayList<org.box2d.proto.Box2D.PbVec2>(normals_);
          bitField0_ |= 0x00000020;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> normalsBuilder_;
      
      public java.util.List<org.box2d.proto.Box2D.PbVec2> getNormalsList() {
        if (normalsBuilder_ == null) {
          return java.util.Collections.unmodifiableList(normals_);
        } else {
          return normalsBuilder_.getMessageList();
        }
      }
      public int getNormalsCount() {
        if (normalsBuilder_ == null) {
          return normals_.size();
        } else {
          return normalsBuilder_.getCount();
        }
      }
      public org.box2d.proto.Box2D.PbVec2 getNormals(int index) {
        if (normalsBuilder_ == null) {
          return normals_.get(index);
        } else {
          return normalsBuilder_.getMessage(index);
        }
      }
      public Builder setNormals(
          int index, org.box2d.proto.Box2D.PbVec2 value) {
        if (normalsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureNormalsIsMutable();
          normals_.set(index, value);
          onChanged();
        } else {
          normalsBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setNormals(
          int index, org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (normalsBuilder_ == null) {
          ensureNormalsIsMutable();
          normals_.set(index, builderForValue.build());
          onChanged();
        } else {
          normalsBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addNormals(org.box2d.proto.Box2D.PbVec2 value) {
        if (normalsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureNormalsIsMutable();
          normals_.add(value);
          onChanged();
        } else {
          normalsBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addNormals(
          int index, org.box2d.proto.Box2D.PbVec2 value) {
        if (normalsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureNormalsIsMutable();
          normals_.add(index, value);
          onChanged();
        } else {
          normalsBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addNormals(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (normalsBuilder_ == null) {
          ensureNormalsIsMutable();
          normals_.add(builderForValue.build());
          onChanged();
        } else {
          normalsBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addNormals(
          int index, org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (normalsBuilder_ == null) {
          ensureNormalsIsMutable();
          normals_.add(index, builderForValue.build());
          onChanged();
        } else {
          normalsBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllNormals(
          java.lang.Iterable<? extends org.box2d.proto.Box2D.PbVec2> values) {
        if (normalsBuilder_ == null) {
          ensureNormalsIsMutable();
          super.addAll(values, normals_);
          onChanged();
        } else {
          normalsBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearNormals() {
        if (normalsBuilder_ == null) {
          normals_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000020);
          onChanged();
        } else {
          normalsBuilder_.clear();
        }
        return this;
      }
      public Builder removeNormals(int index) {
        if (normalsBuilder_ == null) {
          ensureNormalsIsMutable();
          normals_.remove(index);
          onChanged();
        } else {
          normalsBuilder_.remove(index);
        }
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getNormalsBuilder(
          int index) {
        return getNormalsFieldBuilder().getBuilder(index);
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getNormalsOrBuilder(
          int index) {
        if (normalsBuilder_ == null) {
          return normals_.get(index);  } else {
          return normalsBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends org.box2d.proto.Box2D.PbVec2OrBuilder> 
           getNormalsOrBuilderList() {
        if (normalsBuilder_ != null) {
          return normalsBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(normals_);
        }
      }
      public org.box2d.proto.Box2D.PbVec2.Builder addNormalsBuilder() {
        return getNormalsFieldBuilder().addBuilder(
            org.box2d.proto.Box2D.PbVec2.getDefaultInstance());
      }
      public org.box2d.proto.Box2D.PbVec2.Builder addNormalsBuilder(
          int index) {
        return getNormalsFieldBuilder().addBuilder(
            index, org.box2d.proto.Box2D.PbVec2.getDefaultInstance());
      }
      public java.util.List<org.box2d.proto.Box2D.PbVec2.Builder> 
           getNormalsBuilderList() {
        return getNormalsFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getNormalsFieldBuilder() {
        if (normalsBuilder_ == null) {
          normalsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  normals_,
                  ((bitField0_ & 0x00000020) == 0x00000020),
                  getParentForChildren(),
                  isClean());
          normals_ = null;
        }
        return normalsBuilder_;
      }
      
      // optional .box2d.PbVec2 centroid = 22;
      private org.box2d.proto.Box2D.PbVec2 centroid_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> centroidBuilder_;
      public boolean hasCentroid() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public org.box2d.proto.Box2D.PbVec2 getCentroid() {
        if (centroidBuilder_ == null) {
          return centroid_;
        } else {
          return centroidBuilder_.getMessage();
        }
      }
      public Builder setCentroid(org.box2d.proto.Box2D.PbVec2 value) {
        if (centroidBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          centroid_ = value;
          onChanged();
        } else {
          centroidBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder setCentroid(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (centroidBuilder_ == null) {
          centroid_ = builderForValue.build();
          onChanged();
        } else {
          centroidBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder mergeCentroid(org.box2d.proto.Box2D.PbVec2 value) {
        if (centroidBuilder_ == null) {
          if (((bitField0_ & 0x00000040) == 0x00000040) &&
              centroid_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            centroid_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(centroid_).mergeFrom(value).buildPartial();
          } else {
            centroid_ = value;
          }
          onChanged();
        } else {
          centroidBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder clearCentroid() {
        if (centroidBuilder_ == null) {
          centroid_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          centroidBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getCentroidBuilder() {
        bitField0_ |= 0x00000040;
        onChanged();
        return getCentroidFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getCentroidOrBuilder() {
        if (centroidBuilder_ != null) {
          return centroidBuilder_.getMessageOrBuilder();
        } else {
          return centroid_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getCentroidFieldBuilder() {
        if (centroidBuilder_ == null) {
          centroidBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  centroid_,
                  getParentForChildren(),
                  isClean());
          centroid_ = null;
        }
        return centroidBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbShape)
    }
    
    static {
      defaultInstance = new PbShape(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbShape)
  }
  
  public interface PbFixtureOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional int64 tag = 1;
    boolean hasTag();
    long getTag();
    
    // optional float restitution = 2;
    boolean hasRestitution();
    float getRestitution();
    
    // optional float friction = 3;
    boolean hasFriction();
    float getFriction();
    
    // optional float density = 4;
    boolean hasDensity();
    float getDensity();
    
    // optional bool sensor = 5;
    boolean hasSensor();
    boolean getSensor();
    
    // optional .box2d.PbFilter filter = 10;
    boolean hasFilter();
    org.box2d.proto.Box2D.PbFilter getFilter();
    org.box2d.proto.Box2D.PbFilterOrBuilder getFilterOrBuilder();
    
    // optional .box2d.PbShape shape = 11;
    boolean hasShape();
    org.box2d.proto.Box2D.PbShape getShape();
    org.box2d.proto.Box2D.PbShapeOrBuilder getShapeOrBuilder();
  }
  public static final class PbFixture extends
      com.google.protobuf.GeneratedMessage
      implements PbFixtureOrBuilder {
    // Use PbFixture.newBuilder() to construct.
    private PbFixture(Builder builder) {
      super(builder);
    }
    private PbFixture(boolean noInit) {}
    
    private static final PbFixture defaultInstance;
    public static PbFixture getDefaultInstance() {
      return defaultInstance;
    }
    
    public PbFixture getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbFixture_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbFixture_fieldAccessorTable;
    }
    
    private int bitField0_;
    // optional int64 tag = 1;
    public static final int TAG_FIELD_NUMBER = 1;
    private long tag_;
    public boolean hasTag() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public long getTag() {
      return tag_;
    }
    
    // optional float restitution = 2;
    public static final int RESTITUTION_FIELD_NUMBER = 2;
    private float restitution_;
    public boolean hasRestitution() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public float getRestitution() {
      return restitution_;
    }
    
    // optional float friction = 3;
    public static final int FRICTION_FIELD_NUMBER = 3;
    private float friction_;
    public boolean hasFriction() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public float getFriction() {
      return friction_;
    }
    
    // optional float density = 4;
    public static final int DENSITY_FIELD_NUMBER = 4;
    private float density_;
    public boolean hasDensity() {
      return ((bitField0_ & 0x00000008) == 0x00000008);
    }
    public float getDensity() {
      return density_;
    }
    
    // optional bool sensor = 5;
    public static final int SENSOR_FIELD_NUMBER = 5;
    private boolean sensor_;
    public boolean hasSensor() {
      return ((bitField0_ & 0x00000010) == 0x00000010);
    }
    public boolean getSensor() {
      return sensor_;
    }
    
    // optional .box2d.PbFilter filter = 10;
    public static final int FILTER_FIELD_NUMBER = 10;
    private org.box2d.proto.Box2D.PbFilter filter_;
    public boolean hasFilter() {
      return ((bitField0_ & 0x00000020) == 0x00000020);
    }
    public org.box2d.proto.Box2D.PbFilter getFilter() {
      return filter_;
    }
    public org.box2d.proto.Box2D.PbFilterOrBuilder getFilterOrBuilder() {
      return filter_;
    }
    
    // optional .box2d.PbShape shape = 11;
    public static final int SHAPE_FIELD_NUMBER = 11;
    private org.box2d.proto.Box2D.PbShape shape_;
    public boolean hasShape() {
      return ((bitField0_ & 0x00000040) == 0x00000040);
    }
    public org.box2d.proto.Box2D.PbShape getShape() {
      return shape_;
    }
    public org.box2d.proto.Box2D.PbShapeOrBuilder getShapeOrBuilder() {
      return shape_;
    }
    
    private void initFields() {
      tag_ = 0L;
      restitution_ = 0F;
      friction_ = 0F;
      density_ = 0F;
      sensor_ = false;
      filter_ = org.box2d.proto.Box2D.PbFilter.getDefaultInstance();
      shape_ = org.box2d.proto.Box2D.PbShape.getDefaultInstance();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (hasShape()) {
        if (!getShape().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeInt64(1, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeFloat(2, restitution_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeFloat(3, friction_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeFloat(4, density_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeBool(5, sensor_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        output.writeMessage(10, filter_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        output.writeMessage(11, shape_);
      }
      getUnknownFields().writeTo(output);
    }
    
    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, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(2, restitution_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(3, friction_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(4, density_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(5, sensor_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(10, filter_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(11, shape_);
      }
      size += getUnknownFields().getSerializedSize();
      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.box2d.proto.Box2D.PbFixture parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.box2d.proto.Box2D.PbFixture 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;
      }
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbFixture parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.box2d.proto.Box2D.PbFixture prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements org.box2d.proto.Box2D.PbFixtureOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbFixture_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbFixture_fieldAccessorTable;
      }
      
      // Construct using org.box2d.proto.Box2D.PbFixture.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getFilterFieldBuilder();
          getShapeFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        tag_ = 0L;
        bitField0_ = (bitField0_ & ~0x00000001);
        restitution_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000002);
        friction_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000004);
        density_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000008);
        sensor_ = false;
        bitField0_ = (bitField0_ & ~0x00000010);
        if (filterBuilder_ == null) {
          filter_ = org.box2d.proto.Box2D.PbFilter.getDefaultInstance();
        } else {
          filterBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000020);
        if (shapeBuilder_ == null) {
          shape_ = org.box2d.proto.Box2D.PbShape.getDefaultInstance();
        } else {
          shapeBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.box2d.proto.Box2D.PbFixture.getDescriptor();
      }
      
      public org.box2d.proto.Box2D.PbFixture getDefaultInstanceForType() {
        return org.box2d.proto.Box2D.PbFixture.getDefaultInstance();
      }
      
      public org.box2d.proto.Box2D.PbFixture build() {
        org.box2d.proto.Box2D.PbFixture result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private org.box2d.proto.Box2D.PbFixture buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        org.box2d.proto.Box2D.PbFixture result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public org.box2d.proto.Box2D.PbFixture buildPartial() {
        org.box2d.proto.Box2D.PbFixture result = new org.box2d.proto.Box2D.PbFixture(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.tag_ = tag_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.restitution_ = restitution_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.friction_ = friction_;
        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
          to_bitField0_ |= 0x00000008;
        }
        result.density_ = density_;
        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
          to_bitField0_ |= 0x00000010;
        }
        result.sensor_ = sensor_;
        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
          to_bitField0_ |= 0x00000020;
        }
        if (filterBuilder_ == null) {
          result.filter_ = filter_;
        } else {
          result.filter_ = filterBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
          to_bitField0_ |= 0x00000040;
        }
        if (shapeBuilder_ == null) {
          result.shape_ = shape_;
        } else {
          result.shape_ = shapeBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.box2d.proto.Box2D.PbFixture) {
          return mergeFrom((org.box2d.proto.Box2D.PbFixture)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.box2d.proto.Box2D.PbFixture other) {
        if (other == org.box2d.proto.Box2D.PbFixture.getDefaultInstance()) return this;
        if (other.hasTag()) {
          setTag(other.getTag());
        }
        if (other.hasRestitution()) {
          setRestitution(other.getRestitution());
        }
        if (other.hasFriction()) {
          setFriction(other.getFriction());
        }
        if (other.hasDensity()) {
          setDensity(other.getDensity());
        }
        if (other.hasSensor()) {
          setSensor(other.getSensor());
        }
        if (other.hasFilter()) {
          mergeFilter(other.getFilter());
        }
        if (other.hasShape()) {
          mergeShape(other.getShape());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (hasShape()) {
          if (!getShape().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              bitField0_ |= 0x00000001;
              tag_ = input.readInt64();
              break;
            }
            case 21: {
              bitField0_ |= 0x00000002;
              restitution_ = input.readFloat();
              break;
            }
            case 29: {
              bitField0_ |= 0x00000004;
              friction_ = input.readFloat();
              break;
            }
            case 37: {
              bitField0_ |= 0x00000008;
              density_ = input.readFloat();
              break;
            }
            case 40: {
              bitField0_ |= 0x00000010;
              sensor_ = input.readBool();
              break;
            }
            case 82: {
              org.box2d.proto.Box2D.PbFilter.Builder subBuilder = org.box2d.proto.Box2D.PbFilter.newBuilder();
              if (hasFilter()) {
                subBuilder.mergeFrom(getFilter());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setFilter(subBuilder.buildPartial());
              break;
            }
            case 90: {
              org.box2d.proto.Box2D.PbShape.Builder subBuilder = org.box2d.proto.Box2D.PbShape.newBuilder();
              if (hasShape()) {
                subBuilder.mergeFrom(getShape());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setShape(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // optional int64 tag = 1;
      private long tag_ ;
      public boolean hasTag() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public long getTag() {
        return tag_;
      }
      public Builder setTag(long value) {
        bitField0_ |= 0x00000001;
        tag_ = value;
        onChanged();
        return this;
      }
      public Builder clearTag() {
        bitField0_ = (bitField0_ & ~0x00000001);
        tag_ = 0L;
        onChanged();
        return this;
      }
      
      // optional float restitution = 2;
      private float restitution_ ;
      public boolean hasRestitution() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public float getRestitution() {
        return restitution_;
      }
      public Builder setRestitution(float value) {
        bitField0_ |= 0x00000002;
        restitution_ = value;
        onChanged();
        return this;
      }
      public Builder clearRestitution() {
        bitField0_ = (bitField0_ & ~0x00000002);
        restitution_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float friction = 3;
      private float friction_ ;
      public boolean hasFriction() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public float getFriction() {
        return friction_;
      }
      public Builder setFriction(float value) {
        bitField0_ |= 0x00000004;
        friction_ = value;
        onChanged();
        return this;
      }
      public Builder clearFriction() {
        bitField0_ = (bitField0_ & ~0x00000004);
        friction_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float density = 4;
      private float density_ ;
      public boolean hasDensity() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public float getDensity() {
        return density_;
      }
      public Builder setDensity(float value) {
        bitField0_ |= 0x00000008;
        density_ = value;
        onChanged();
        return this;
      }
      public Builder clearDensity() {
        bitField0_ = (bitField0_ & ~0x00000008);
        density_ = 0F;
        onChanged();
        return this;
      }
      
      // optional bool sensor = 5;
      private boolean sensor_ ;
      public boolean hasSensor() {
        return ((bitField0_ & 0x00000010) == 0x00000010);
      }
      public boolean getSensor() {
        return sensor_;
      }
      public Builder setSensor(boolean value) {
        bitField0_ |= 0x00000010;
        sensor_ = value;
        onChanged();
        return this;
      }
      public Builder clearSensor() {
        bitField0_ = (bitField0_ & ~0x00000010);
        sensor_ = false;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbFilter filter = 10;
      private org.box2d.proto.Box2D.PbFilter filter_ = org.box2d.proto.Box2D.PbFilter.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbFilter, org.box2d.proto.Box2D.PbFilter.Builder, org.box2d.proto.Box2D.PbFilterOrBuilder> filterBuilder_;
      public boolean hasFilter() {
        return ((bitField0_ & 0x00000020) == 0x00000020);
      }
      public org.box2d.proto.Box2D.PbFilter getFilter() {
        if (filterBuilder_ == null) {
          return filter_;
        } else {
          return filterBuilder_.getMessage();
        }
      }
      public Builder setFilter(org.box2d.proto.Box2D.PbFilter value) {
        if (filterBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          filter_ = value;
          onChanged();
        } else {
          filterBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder setFilter(
          org.box2d.proto.Box2D.PbFilter.Builder builderForValue) {
        if (filterBuilder_ == null) {
          filter_ = builderForValue.build();
          onChanged();
        } else {
          filterBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder mergeFilter(org.box2d.proto.Box2D.PbFilter value) {
        if (filterBuilder_ == null) {
          if (((bitField0_ & 0x00000020) == 0x00000020) &&
              filter_ != org.box2d.proto.Box2D.PbFilter.getDefaultInstance()) {
            filter_ =
              org.box2d.proto.Box2D.PbFilter.newBuilder(filter_).mergeFrom(value).buildPartial();
          } else {
            filter_ = value;
          }
          onChanged();
        } else {
          filterBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder clearFilter() {
        if (filterBuilder_ == null) {
          filter_ = org.box2d.proto.Box2D.PbFilter.getDefaultInstance();
          onChanged();
        } else {
          filterBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000020);
        return this;
      }
      public org.box2d.proto.Box2D.PbFilter.Builder getFilterBuilder() {
        bitField0_ |= 0x00000020;
        onChanged();
        return getFilterFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbFilterOrBuilder getFilterOrBuilder() {
        if (filterBuilder_ != null) {
          return filterBuilder_.getMessageOrBuilder();
        } else {
          return filter_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbFilter, org.box2d.proto.Box2D.PbFilter.Builder, org.box2d.proto.Box2D.PbFilterOrBuilder> 
          getFilterFieldBuilder() {
        if (filterBuilder_ == null) {
          filterBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbFilter, org.box2d.proto.Box2D.PbFilter.Builder, org.box2d.proto.Box2D.PbFilterOrBuilder>(
                  filter_,
                  getParentForChildren(),
                  isClean());
          filter_ = null;
        }
        return filterBuilder_;
      }
      
      // optional .box2d.PbShape shape = 11;
      private org.box2d.proto.Box2D.PbShape shape_ = org.box2d.proto.Box2D.PbShape.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbShape, org.box2d.proto.Box2D.PbShape.Builder, org.box2d.proto.Box2D.PbShapeOrBuilder> shapeBuilder_;
      public boolean hasShape() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public org.box2d.proto.Box2D.PbShape getShape() {
        if (shapeBuilder_ == null) {
          return shape_;
        } else {
          return shapeBuilder_.getMessage();
        }
      }
      public Builder setShape(org.box2d.proto.Box2D.PbShape value) {
        if (shapeBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          shape_ = value;
          onChanged();
        } else {
          shapeBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder setShape(
          org.box2d.proto.Box2D.PbShape.Builder builderForValue) {
        if (shapeBuilder_ == null) {
          shape_ = builderForValue.build();
          onChanged();
        } else {
          shapeBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder mergeShape(org.box2d.proto.Box2D.PbShape value) {
        if (shapeBuilder_ == null) {
          if (((bitField0_ & 0x00000040) == 0x00000040) &&
              shape_ != org.box2d.proto.Box2D.PbShape.getDefaultInstance()) {
            shape_ =
              org.box2d.proto.Box2D.PbShape.newBuilder(shape_).mergeFrom(value).buildPartial();
          } else {
            shape_ = value;
          }
          onChanged();
        } else {
          shapeBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder clearShape() {
        if (shapeBuilder_ == null) {
          shape_ = org.box2d.proto.Box2D.PbShape.getDefaultInstance();
          onChanged();
        } else {
          shapeBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      public org.box2d.proto.Box2D.PbShape.Builder getShapeBuilder() {
        bitField0_ |= 0x00000040;
        onChanged();
        return getShapeFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbShapeOrBuilder getShapeOrBuilder() {
        if (shapeBuilder_ != null) {
          return shapeBuilder_.getMessageOrBuilder();
        } else {
          return shape_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbShape, org.box2d.proto.Box2D.PbShape.Builder, org.box2d.proto.Box2D.PbShapeOrBuilder> 
          getShapeFieldBuilder() {
        if (shapeBuilder_ == null) {
          shapeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbShape, org.box2d.proto.Box2D.PbShape.Builder, org.box2d.proto.Box2D.PbShapeOrBuilder>(
                  shape_,
                  getParentForChildren(),
                  isClean());
          shape_ = null;
        }
        return shapeBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbFixture)
    }
    
    static {
      defaultInstance = new PbFixture(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbFixture)
  }
  
  public interface PbJointOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional int64 tag = 1;
    boolean hasTag();
    long getTag();
    
    // required .box2d.PbJointType type = 2;
    boolean hasType();
    org.box2d.proto.Box2D.PbJointType getType();
    
    // optional int32 body_a = 3;
    boolean hasBodyA();
    int getBodyA();
    
    // optional int32 body_b = 4;
    boolean hasBodyB();
    int getBodyB();
    
    // optional bool collideConnected = 5;
    boolean hasCollideConnected();
    boolean getCollideConnected();
    
    // optional .box2d.PbVec2 local_anchor_a = 6;
    boolean hasLocalAnchorA();
    org.box2d.proto.Box2D.PbVec2 getLocalAnchorA();
    org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorAOrBuilder();
    
    // optional .box2d.PbVec2 local_anchor_b = 7;
    boolean hasLocalAnchorB();
    org.box2d.proto.Box2D.PbVec2 getLocalAnchorB();
    org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorBOrBuilder();
    
    // optional float ref_angle = 10;
    boolean hasRefAngle();
    float getRefAngle();
    
    // optional bool enable_limit = 12;
    boolean hasEnableLimit();
    boolean getEnableLimit();
    
    // optional float lower_limit = 13;
    boolean hasLowerLimit();
    float getLowerLimit();
    
    // optional float upper_limit = 14;
    boolean hasUpperLimit();
    float getUpperLimit();
    
    // optional bool enable_motor = 15;
    boolean hasEnableMotor();
    boolean getEnableMotor();
    
    // optional float motor_speed = 16;
    boolean hasMotorSpeed();
    float getMotorSpeed();
    
    // optional float max_motor_torque = 17;
    boolean hasMaxMotorTorque();
    float getMaxMotorTorque();
    
    // optional .box2d.PbVec2 local_axis_a = 20;
    boolean hasLocalAxisA();
    org.box2d.proto.Box2D.PbVec2 getLocalAxisA();
    org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAxisAOrBuilder();
    
    // optional float max_motor_force = 21;
    boolean hasMaxMotorForce();
    float getMaxMotorForce();
    
    // optional float length = 30;
    boolean hasLength();
    float getLength();
    
    // optional float frequency = 31;
    boolean hasFrequency();
    float getFrequency();
    
    // optional float damping_ratio = 32;
    boolean hasDampingRatio();
    float getDampingRatio();
    
    // optional .box2d.PbVec2 ground_anchor_a = 40;
    boolean hasGroundAnchorA();
    org.box2d.proto.Box2D.PbVec2 getGroundAnchorA();
    org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorAOrBuilder();
    
    // optional .box2d.PbVec2 ground_anchor_b = 41;
    boolean hasGroundAnchorB();
    org.box2d.proto.Box2D.PbVec2 getGroundAnchorB();
    org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorBOrBuilder();
    
    // optional float length_a = 42;
    boolean hasLengthA();
    float getLengthA();
    
    // optional float length_b = 43;
    boolean hasLengthB();
    float getLengthB();
    
    // optional float ratio = 44;
    boolean hasRatio();
    float getRatio();
    
    // optional float max_length_a = 45;
    boolean hasMaxLengthA();
    float getMaxLengthA();
    
    // optional float max_length_b = 46;
    boolean hasMaxLengthB();
    float getMaxLengthB();
    
    // optional .box2d.PbVec2 target = 50;
    boolean hasTarget();
    org.box2d.proto.Box2D.PbVec2 getTarget();
    org.box2d.proto.Box2D.PbVec2OrBuilder getTargetOrBuilder();
    
    // optional float max_force = 51;
    boolean hasMaxForce();
    float getMaxForce();
    
    // optional int32 joint1 = 61;
    boolean hasJoint1();
    int getJoint1();
    
    // optional int32 joint2 = 62;
    boolean hasJoint2();
    int getJoint2();
    
    // optional float spring_frequency = 70;
    boolean hasSpringFrequency();
    float getSpringFrequency();
    
    // optional float spring_damping_ratio = 71;
    boolean hasSpringDampingRatio();
    float getSpringDampingRatio();
    
    // optional float max_torque = 90;
    boolean hasMaxTorque();
    float getMaxTorque();
    
    // optional float max_length = 100;
    boolean hasMaxLength();
    float getMaxLength();
    
    // repeated int32 bodies = 110;
    java.util.List<java.lang.Integer> getBodiesList();
    int getBodiesCount();
    int getBodies(int index);
    
    // repeated int32 joints = 111;
    java.util.List<java.lang.Integer> getJointsList();
    int getJointsCount();
    int getJoints(int index);
    
    // optional float target_volume = 112;
    boolean hasTargetVolume();
    float getTargetVolume();
  }
  public static final class PbJoint extends
      com.google.protobuf.GeneratedMessage
      implements PbJointOrBuilder {
    // Use PbJoint.newBuilder() to construct.
    private PbJoint(Builder builder) {
      super(builder);
    }
    private PbJoint(boolean noInit) {}
    
    private static final PbJoint defaultInstance;
    public static PbJoint getDefaultInstance() {
      return defaultInstance;
    }
    
    public PbJoint getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbJoint_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbJoint_fieldAccessorTable;
    }
    
    private int bitField0_;
    private int bitField1_;
    // optional int64 tag = 1;
    public static final int TAG_FIELD_NUMBER = 1;
    private long tag_;
    public boolean hasTag() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public long getTag() {
      return tag_;
    }
    
    // required .box2d.PbJointType type = 2;
    public static final int TYPE_FIELD_NUMBER = 2;
    private org.box2d.proto.Box2D.PbJointType type_;
    public boolean hasType() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public org.box2d.proto.Box2D.PbJointType getType() {
      return type_;
    }
    
    // optional int32 body_a = 3;
    public static final int BODY_A_FIELD_NUMBER = 3;
    private int bodyA_;
    public boolean hasBodyA() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public int getBodyA() {
      return bodyA_;
    }
    
    // optional int32 body_b = 4;
    public static final int BODY_B_FIELD_NUMBER = 4;
    private int bodyB_;
    public boolean hasBodyB() {
      return ((bitField0_ & 0x00000008) == 0x00000008);
    }
    public int getBodyB() {
      return bodyB_;
    }
    
    // optional bool collideConnected = 5;
    public static final int COLLIDECONNECTED_FIELD_NUMBER = 5;
    private boolean collideConnected_;
    public boolean hasCollideConnected() {
      return ((bitField0_ & 0x00000010) == 0x00000010);
    }
    public boolean getCollideConnected() {
      return collideConnected_;
    }
    
    // optional .box2d.PbVec2 local_anchor_a = 6;
    public static final int LOCAL_ANCHOR_A_FIELD_NUMBER = 6;
    private org.box2d.proto.Box2D.PbVec2 localAnchorA_;
    public boolean hasLocalAnchorA() {
      return ((bitField0_ & 0x00000020) == 0x00000020);
    }
    public org.box2d.proto.Box2D.PbVec2 getLocalAnchorA() {
      return localAnchorA_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorAOrBuilder() {
      return localAnchorA_;
    }
    
    // optional .box2d.PbVec2 local_anchor_b = 7;
    public static final int LOCAL_ANCHOR_B_FIELD_NUMBER = 7;
    private org.box2d.proto.Box2D.PbVec2 localAnchorB_;
    public boolean hasLocalAnchorB() {
      return ((bitField0_ & 0x00000040) == 0x00000040);
    }
    public org.box2d.proto.Box2D.PbVec2 getLocalAnchorB() {
      return localAnchorB_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorBOrBuilder() {
      return localAnchorB_;
    }
    
    // optional float ref_angle = 10;
    public static final int REF_ANGLE_FIELD_NUMBER = 10;
    private float refAngle_;
    public boolean hasRefAngle() {
      return ((bitField0_ & 0x00000080) == 0x00000080);
    }
    public float getRefAngle() {
      return refAngle_;
    }
    
    // optional bool enable_limit = 12;
    public static final int ENABLE_LIMIT_FIELD_NUMBER = 12;
    private boolean enableLimit_;
    public boolean hasEnableLimit() {
      return ((bitField0_ & 0x00000100) == 0x00000100);
    }
    public boolean getEnableLimit() {
      return enableLimit_;
    }
    
    // optional float lower_limit = 13;
    public static final int LOWER_LIMIT_FIELD_NUMBER = 13;
    private float lowerLimit_;
    public boolean hasLowerLimit() {
      return ((bitField0_ & 0x00000200) == 0x00000200);
    }
    public float getLowerLimit() {
      return lowerLimit_;
    }
    
    // optional float upper_limit = 14;
    public static final int UPPER_LIMIT_FIELD_NUMBER = 14;
    private float upperLimit_;
    public boolean hasUpperLimit() {
      return ((bitField0_ & 0x00000400) == 0x00000400);
    }
    public float getUpperLimit() {
      return upperLimit_;
    }
    
    // optional bool enable_motor = 15;
    public static final int ENABLE_MOTOR_FIELD_NUMBER = 15;
    private boolean enableMotor_;
    public boolean hasEnableMotor() {
      return ((bitField0_ & 0x00000800) == 0x00000800);
    }
    public boolean getEnableMotor() {
      return enableMotor_;
    }
    
    // optional float motor_speed = 16;
    public static final int MOTOR_SPEED_FIELD_NUMBER = 16;
    private float motorSpeed_;
    public boolean hasMotorSpeed() {
      return ((bitField0_ & 0x00001000) == 0x00001000);
    }
    public float getMotorSpeed() {
      return motorSpeed_;
    }
    
    // optional float max_motor_torque = 17;
    public static final int MAX_MOTOR_TORQUE_FIELD_NUMBER = 17;
    private float maxMotorTorque_;
    public boolean hasMaxMotorTorque() {
      return ((bitField0_ & 0x00002000) == 0x00002000);
    }
    public float getMaxMotorTorque() {
      return maxMotorTorque_;
    }
    
    // optional .box2d.PbVec2 local_axis_a = 20;
    public static final int LOCAL_AXIS_A_FIELD_NUMBER = 20;
    private org.box2d.proto.Box2D.PbVec2 localAxisA_;
    public boolean hasLocalAxisA() {
      return ((bitField0_ & 0x00004000) == 0x00004000);
    }
    public org.box2d.proto.Box2D.PbVec2 getLocalAxisA() {
      return localAxisA_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAxisAOrBuilder() {
      return localAxisA_;
    }
    
    // optional float max_motor_force = 21;
    public static final int MAX_MOTOR_FORCE_FIELD_NUMBER = 21;
    private float maxMotorForce_;
    public boolean hasMaxMotorForce() {
      return ((bitField0_ & 0x00008000) == 0x00008000);
    }
    public float getMaxMotorForce() {
      return maxMotorForce_;
    }
    
    // optional float length = 30;
    public static final int LENGTH_FIELD_NUMBER = 30;
    private float length_;
    public boolean hasLength() {
      return ((bitField0_ & 0x00010000) == 0x00010000);
    }
    public float getLength() {
      return length_;
    }
    
    // optional float frequency = 31;
    public static final int FREQUENCY_FIELD_NUMBER = 31;
    private float frequency_;
    public boolean hasFrequency() {
      return ((bitField0_ & 0x00020000) == 0x00020000);
    }
    public float getFrequency() {
      return frequency_;
    }
    
    // optional float damping_ratio = 32;
    public static final int DAMPING_RATIO_FIELD_NUMBER = 32;
    private float dampingRatio_;
    public boolean hasDampingRatio() {
      return ((bitField0_ & 0x00040000) == 0x00040000);
    }
    public float getDampingRatio() {
      return dampingRatio_;
    }
    
    // optional .box2d.PbVec2 ground_anchor_a = 40;
    public static final int GROUND_ANCHOR_A_FIELD_NUMBER = 40;
    private org.box2d.proto.Box2D.PbVec2 groundAnchorA_;
    public boolean hasGroundAnchorA() {
      return ((bitField0_ & 0x00080000) == 0x00080000);
    }
    public org.box2d.proto.Box2D.PbVec2 getGroundAnchorA() {
      return groundAnchorA_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorAOrBuilder() {
      return groundAnchorA_;
    }
    
    // optional .box2d.PbVec2 ground_anchor_b = 41;
    public static final int GROUND_ANCHOR_B_FIELD_NUMBER = 41;
    private org.box2d.proto.Box2D.PbVec2 groundAnchorB_;
    public boolean hasGroundAnchorB() {
      return ((bitField0_ & 0x00100000) == 0x00100000);
    }
    public org.box2d.proto.Box2D.PbVec2 getGroundAnchorB() {
      return groundAnchorB_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorBOrBuilder() {
      return groundAnchorB_;
    }
    
    // optional float length_a = 42;
    public static final int LENGTH_A_FIELD_NUMBER = 42;
    private float lengthA_;
    public boolean hasLengthA() {
      return ((bitField0_ & 0x00200000) == 0x00200000);
    }
    public float getLengthA() {
      return lengthA_;
    }
    
    // optional float length_b = 43;
    public static final int LENGTH_B_FIELD_NUMBER = 43;
    private float lengthB_;
    public boolean hasLengthB() {
      return ((bitField0_ & 0x00400000) == 0x00400000);
    }
    public float getLengthB() {
      return lengthB_;
    }
    
    // optional float ratio = 44;
    public static final int RATIO_FIELD_NUMBER = 44;
    private float ratio_;
    public boolean hasRatio() {
      return ((bitField0_ & 0x00800000) == 0x00800000);
    }
    public float getRatio() {
      return ratio_;
    }
    
    // optional float max_length_a = 45;
    public static final int MAX_LENGTH_A_FIELD_NUMBER = 45;
    private float maxLengthA_;
    public boolean hasMaxLengthA() {
      return ((bitField0_ & 0x01000000) == 0x01000000);
    }
    public float getMaxLengthA() {
      return maxLengthA_;
    }
    
    // optional float max_length_b = 46;
    public static final int MAX_LENGTH_B_FIELD_NUMBER = 46;
    private float maxLengthB_;
    public boolean hasMaxLengthB() {
      return ((bitField0_ & 0x02000000) == 0x02000000);
    }
    public float getMaxLengthB() {
      return maxLengthB_;
    }
    
    // optional .box2d.PbVec2 target = 50;
    public static final int TARGET_FIELD_NUMBER = 50;
    private org.box2d.proto.Box2D.PbVec2 target_;
    public boolean hasTarget() {
      return ((bitField0_ & 0x04000000) == 0x04000000);
    }
    public org.box2d.proto.Box2D.PbVec2 getTarget() {
      return target_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getTargetOrBuilder() {
      return target_;
    }
    
    // optional float max_force = 51;
    public static final int MAX_FORCE_FIELD_NUMBER = 51;
    private float maxForce_;
    public boolean hasMaxForce() {
      return ((bitField0_ & 0x08000000) == 0x08000000);
    }
    public float getMaxForce() {
      return maxForce_;
    }
    
    // optional int32 joint1 = 61;
    public static final int JOINT1_FIELD_NUMBER = 61;
    private int joint1_;
    public boolean hasJoint1() {
      return ((bitField0_ & 0x10000000) == 0x10000000);
    }
    public int getJoint1() {
      return joint1_;
    }
    
    // optional int32 joint2 = 62;
    public static final int JOINT2_FIELD_NUMBER = 62;
    private int joint2_;
    public boolean hasJoint2() {
      return ((bitField0_ & 0x20000000) == 0x20000000);
    }
    public int getJoint2() {
      return joint2_;
    }
    
    // optional float spring_frequency = 70;
    public static final int SPRING_FREQUENCY_FIELD_NUMBER = 70;
    private float springFrequency_;
    public boolean hasSpringFrequency() {
      return ((bitField0_ & 0x40000000) == 0x40000000);
    }
    public float getSpringFrequency() {
      return springFrequency_;
    }
    
    // optional float spring_damping_ratio = 71;
    public static final int SPRING_DAMPING_RATIO_FIELD_NUMBER = 71;
    private float springDampingRatio_;
    public boolean hasSpringDampingRatio() {
      return ((bitField0_ & 0x80000000) == 0x80000000);
    }
    public float getSpringDampingRatio() {
      return springDampingRatio_;
    }
    
    // optional float max_torque = 90;
    public static final int MAX_TORQUE_FIELD_NUMBER = 90;
    private float maxTorque_;
    public boolean hasMaxTorque() {
      return ((bitField1_ & 0x00000001) == 0x00000001);
    }
    public float getMaxTorque() {
      return maxTorque_;
    }
    
    // optional float max_length = 100;
    public static final int MAX_LENGTH_FIELD_NUMBER = 100;
    private float maxLength_;
    public boolean hasMaxLength() {
      return ((bitField1_ & 0x00000002) == 0x00000002);
    }
    public float getMaxLength() {
      return maxLength_;
    }
    
    // repeated int32 bodies = 110;
    public static final int BODIES_FIELD_NUMBER = 110;
    private java.util.List<java.lang.Integer> bodies_;
    public java.util.List<java.lang.Integer>
        getBodiesList() {
      return bodies_;
    }
    public int getBodiesCount() {
      return bodies_.size();
    }
    public int getBodies(int index) {
      return bodies_.get(index);
    }
    
    // repeated int32 joints = 111;
    public static final int JOINTS_FIELD_NUMBER = 111;
    private java.util.List<java.lang.Integer> joints_;
    public java.util.List<java.lang.Integer>
        getJointsList() {
      return joints_;
    }
    public int getJointsCount() {
      return joints_.size();
    }
    public int getJoints(int index) {
      return joints_.get(index);
    }
    
    // optional float target_volume = 112;
    public static final int TARGET_VOLUME_FIELD_NUMBER = 112;
    private float targetVolume_;
    public boolean hasTargetVolume() {
      return ((bitField1_ & 0x00000004) == 0x00000004);
    }
    public float getTargetVolume() {
      return targetVolume_;
    }
    
    private void initFields() {
      tag_ = 0L;
      type_ = org.box2d.proto.Box2D.PbJointType.DISTANCE;
      bodyA_ = 0;
      bodyB_ = 0;
      collideConnected_ = false;
      localAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      localAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      refAngle_ = 0F;
      enableLimit_ = false;
      lowerLimit_ = 0F;
      upperLimit_ = 0F;
      enableMotor_ = false;
      motorSpeed_ = 0F;
      maxMotorTorque_ = 0F;
      localAxisA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      maxMotorForce_ = 0F;
      length_ = 0F;
      frequency_ = 0F;
      dampingRatio_ = 0F;
      groundAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      groundAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      lengthA_ = 0F;
      lengthB_ = 0F;
      ratio_ = 0F;
      maxLengthA_ = 0F;
      maxLengthB_ = 0F;
      target_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      maxForce_ = 0F;
      joint1_ = 0;
      joint2_ = 0;
      springFrequency_ = 0F;
      springDampingRatio_ = 0F;
      maxTorque_ = 0F;
      maxLength_ = 0F;
      bodies_ = java.util.Collections.emptyList();;
      joints_ = java.util.Collections.emptyList();;
      targetVolume_ = 0F;
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasType()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasLocalAnchorA()) {
        if (!getLocalAnchorA().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasLocalAnchorB()) {
        if (!getLocalAnchorB().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasLocalAxisA()) {
        if (!getLocalAxisA().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasGroundAnchorA()) {
        if (!getGroundAnchorA().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasGroundAnchorB()) {
        if (!getGroundAnchorB().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasTarget()) {
        if (!getTarget().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeInt64(1, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeEnum(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeInt32(3, bodyA_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeInt32(4, bodyB_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeBool(5, collideConnected_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        output.writeMessage(6, localAnchorA_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        output.writeMessage(7, localAnchorB_);
      }
      if (((bitField0_ & 0x00000080) == 0x00000080)) {
        output.writeFloat(10, refAngle_);
      }
      if (((bitField0_ & 0x00000100) == 0x00000100)) {
        output.writeBool(12, enableLimit_);
      }
      if (((bitField0_ & 0x00000200) == 0x00000200)) {
        output.writeFloat(13, lowerLimit_);
      }
      if (((bitField0_ & 0x00000400) == 0x00000400)) {
        output.writeFloat(14, upperLimit_);
      }
      if (((bitField0_ & 0x00000800) == 0x00000800)) {
        output.writeBool(15, enableMotor_);
      }
      if (((bitField0_ & 0x00001000) == 0x00001000)) {
        output.writeFloat(16, motorSpeed_);
      }
      if (((bitField0_ & 0x00002000) == 0x00002000)) {
        output.writeFloat(17, maxMotorTorque_);
      }
      if (((bitField0_ & 0x00004000) == 0x00004000)) {
        output.writeMessage(20, localAxisA_);
      }
      if (((bitField0_ & 0x00008000) == 0x00008000)) {
        output.writeFloat(21, maxMotorForce_);
      }
      if (((bitField0_ & 0x00010000) == 0x00010000)) {
        output.writeFloat(30, length_);
      }
      if (((bitField0_ & 0x00020000) == 0x00020000)) {
        output.writeFloat(31, frequency_);
      }
      if (((bitField0_ & 0x00040000) == 0x00040000)) {
        output.writeFloat(32, dampingRatio_);
      }
      if (((bitField0_ & 0x00080000) == 0x00080000)) {
        output.writeMessage(40, groundAnchorA_);
      }
      if (((bitField0_ & 0x00100000) == 0x00100000)) {
        output.writeMessage(41, groundAnchorB_);
      }
      if (((bitField0_ & 0x00200000) == 0x00200000)) {
        output.writeFloat(42, lengthA_);
      }
      if (((bitField0_ & 0x00400000) == 0x00400000)) {
        output.writeFloat(43, lengthB_);
      }
      if (((bitField0_ & 0x00800000) == 0x00800000)) {
        output.writeFloat(44, ratio_);
      }
      if (((bitField0_ & 0x01000000) == 0x01000000)) {
        output.writeFloat(45, maxLengthA_);
      }
      if (((bitField0_ & 0x02000000) == 0x02000000)) {
        output.writeFloat(46, maxLengthB_);
      }
      if (((bitField0_ & 0x04000000) == 0x04000000)) {
        output.writeMessage(50, target_);
      }
      if (((bitField0_ & 0x08000000) == 0x08000000)) {
        output.writeFloat(51, maxForce_);
      }
      if (((bitField0_ & 0x10000000) == 0x10000000)) {
        output.writeInt32(61, joint1_);
      }
      if (((bitField0_ & 0x20000000) == 0x20000000)) {
        output.writeInt32(62, joint2_);
      }
      if (((bitField0_ & 0x40000000) == 0x40000000)) {
        output.writeFloat(70, springFrequency_);
      }
      if (((bitField0_ & 0x80000000) == 0x80000000)) {
        output.writeFloat(71, springDampingRatio_);
      }
      if (((bitField1_ & 0x00000001) == 0x00000001)) {
        output.writeFloat(90, maxTorque_);
      }
      if (((bitField1_ & 0x00000002) == 0x00000002)) {
        output.writeFloat(100, maxLength_);
      }
      for (int i = 0; i < bodies_.size(); i++) {
        output.writeInt32(110, bodies_.get(i));
      }
      for (int i = 0; i < joints_.size(); i++) {
        output.writeInt32(111, joints_.get(i));
      }
      if (((bitField1_ & 0x00000004) == 0x00000004)) {
        output.writeFloat(112, targetVolume_);
      }
      getUnknownFields().writeTo(output);
    }
    
    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, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(3, bodyA_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(4, bodyB_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(5, collideConnected_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(6, localAnchorA_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(7, localAnchorB_);
      }
      if (((bitField0_ & 0x00000080) == 0x00000080)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(10, refAngle_);
      }
      if (((bitField0_ & 0x00000100) == 0x00000100)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(12, enableLimit_);
      }
      if (((bitField0_ & 0x00000200) == 0x00000200)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(13, lowerLimit_);
      }
      if (((bitField0_ & 0x00000400) == 0x00000400)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(14, upperLimit_);
      }
      if (((bitField0_ & 0x00000800) == 0x00000800)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(15, enableMotor_);
      }
      if (((bitField0_ & 0x00001000) == 0x00001000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(16, motorSpeed_);
      }
      if (((bitField0_ & 0x00002000) == 0x00002000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(17, maxMotorTorque_);
      }
      if (((bitField0_ & 0x00004000) == 0x00004000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(20, localAxisA_);
      }
      if (((bitField0_ & 0x00008000) == 0x00008000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(21, maxMotorForce_);
      }
      if (((bitField0_ & 0x00010000) == 0x00010000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(30, length_);
      }
      if (((bitField0_ & 0x00020000) == 0x00020000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(31, frequency_);
      }
      if (((bitField0_ & 0x00040000) == 0x00040000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(32, dampingRatio_);
      }
      if (((bitField0_ & 0x00080000) == 0x00080000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(40, groundAnchorA_);
      }
      if (((bitField0_ & 0x00100000) == 0x00100000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(41, groundAnchorB_);
      }
      if (((bitField0_ & 0x00200000) == 0x00200000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(42, lengthA_);
      }
      if (((bitField0_ & 0x00400000) == 0x00400000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(43, lengthB_);
      }
      if (((bitField0_ & 0x00800000) == 0x00800000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(44, ratio_);
      }
      if (((bitField0_ & 0x01000000) == 0x01000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(45, maxLengthA_);
      }
      if (((bitField0_ & 0x02000000) == 0x02000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(46, maxLengthB_);
      }
      if (((bitField0_ & 0x04000000) == 0x04000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(50, target_);
      }
      if (((bitField0_ & 0x08000000) == 0x08000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(51, maxForce_);
      }
      if (((bitField0_ & 0x10000000) == 0x10000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(61, joint1_);
      }
      if (((bitField0_ & 0x20000000) == 0x20000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeInt32Size(62, joint2_);
      }
      if (((bitField0_ & 0x40000000) == 0x40000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(70, springFrequency_);
      }
      if (((bitField0_ & 0x80000000) == 0x80000000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(71, springDampingRatio_);
      }
      if (((bitField1_ & 0x00000001) == 0x00000001)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(90, maxTorque_);
      }
      if (((bitField1_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(100, maxLength_);
      }
      {
        int dataSize = 0;
        for (int i = 0; i < bodies_.size(); i++) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeInt32SizeNoTag(bodies_.get(i));
        }
        size += dataSize;
        size += 2 * getBodiesList().size();
      }
      {
        int dataSize = 0;
        for (int i = 0; i < joints_.size(); i++) {
          dataSize += com.google.protobuf.CodedOutputStream
            .computeInt32SizeNoTag(joints_.get(i));
        }
        size += dataSize;
        size += 2 * getJointsList().size();
      }
      if (((bitField1_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(112, targetVolume_);
      }
      size += getUnknownFields().getSerializedSize();
      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.box2d.proto.Box2D.PbJoint parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.box2d.proto.Box2D.PbJoint 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;
      }
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbJoint parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.box2d.proto.Box2D.PbJoint prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements org.box2d.proto.Box2D.PbJointOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbJoint_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbJoint_fieldAccessorTable;
      }
      
      // Construct using org.box2d.proto.Box2D.PbJoint.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getLocalAnchorAFieldBuilder();
          getLocalAnchorBFieldBuilder();
          getLocalAxisAFieldBuilder();
          getGroundAnchorAFieldBuilder();
          getGroundAnchorBFieldBuilder();
          getTargetFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        tag_ = 0L;
        bitField0_ = (bitField0_ & ~0x00000001);
        type_ = org.box2d.proto.Box2D.PbJointType.DISTANCE;
        bitField0_ = (bitField0_ & ~0x00000002);
        bodyA_ = 0;
        bitField0_ = (bitField0_ & ~0x00000004);
        bodyB_ = 0;
        bitField0_ = (bitField0_ & ~0x00000008);
        collideConnected_ = false;
        bitField0_ = (bitField0_ & ~0x00000010);
        if (localAnchorABuilder_ == null) {
          localAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          localAnchorABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000020);
        if (localAnchorBBuilder_ == null) {
          localAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          localAnchorBBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        refAngle_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000080);
        enableLimit_ = false;
        bitField0_ = (bitField0_ & ~0x00000100);
        lowerLimit_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000200);
        upperLimit_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000400);
        enableMotor_ = false;
        bitField0_ = (bitField0_ & ~0x00000800);
        motorSpeed_ = 0F;
        bitField0_ = (bitField0_ & ~0x00001000);
        maxMotorTorque_ = 0F;
        bitField0_ = (bitField0_ & ~0x00002000);
        if (localAxisABuilder_ == null) {
          localAxisA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          localAxisABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00004000);
        maxMotorForce_ = 0F;
        bitField0_ = (bitField0_ & ~0x00008000);
        length_ = 0F;
        bitField0_ = (bitField0_ & ~0x00010000);
        frequency_ = 0F;
        bitField0_ = (bitField0_ & ~0x00020000);
        dampingRatio_ = 0F;
        bitField0_ = (bitField0_ & ~0x00040000);
        if (groundAnchorABuilder_ == null) {
          groundAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          groundAnchorABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00080000);
        if (groundAnchorBBuilder_ == null) {
          groundAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          groundAnchorBBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00100000);
        lengthA_ = 0F;
        bitField0_ = (bitField0_ & ~0x00200000);
        lengthB_ = 0F;
        bitField0_ = (bitField0_ & ~0x00400000);
        ratio_ = 0F;
        bitField0_ = (bitField0_ & ~0x00800000);
        maxLengthA_ = 0F;
        bitField0_ = (bitField0_ & ~0x01000000);
        maxLengthB_ = 0F;
        bitField0_ = (bitField0_ & ~0x02000000);
        if (targetBuilder_ == null) {
          target_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          targetBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x04000000);
        maxForce_ = 0F;
        bitField0_ = (bitField0_ & ~0x08000000);
        joint1_ = 0;
        bitField0_ = (bitField0_ & ~0x10000000);
        joint2_ = 0;
        bitField0_ = (bitField0_ & ~0x20000000);
        springFrequency_ = 0F;
        bitField0_ = (bitField0_ & ~0x40000000);
        springDampingRatio_ = 0F;
        bitField0_ = (bitField0_ & ~0x80000000);
        maxTorque_ = 0F;
        bitField1_ = (bitField1_ & ~0x00000001);
        maxLength_ = 0F;
        bitField1_ = (bitField1_ & ~0x00000002);
        bodies_ = java.util.Collections.emptyList();;
        bitField1_ = (bitField1_ & ~0x00000004);
        joints_ = java.util.Collections.emptyList();;
        bitField1_ = (bitField1_ & ~0x00000008);
        targetVolume_ = 0F;
        bitField1_ = (bitField1_ & ~0x00000010);
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.box2d.proto.Box2D.PbJoint.getDescriptor();
      }
      
      public org.box2d.proto.Box2D.PbJoint getDefaultInstanceForType() {
        return org.box2d.proto.Box2D.PbJoint.getDefaultInstance();
      }
      
      public org.box2d.proto.Box2D.PbJoint build() {
        org.box2d.proto.Box2D.PbJoint result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private org.box2d.proto.Box2D.PbJoint buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        org.box2d.proto.Box2D.PbJoint result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public org.box2d.proto.Box2D.PbJoint buildPartial() {
        org.box2d.proto.Box2D.PbJoint result = new org.box2d.proto.Box2D.PbJoint(this);
        int from_bitField0_ = bitField0_;
        int from_bitField1_ = bitField1_;
        int to_bitField0_ = 0;
        int to_bitField1_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.tag_ = tag_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.type_ = type_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.bodyA_ = bodyA_;
        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
          to_bitField0_ |= 0x00000008;
        }
        result.bodyB_ = bodyB_;
        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
          to_bitField0_ |= 0x00000010;
        }
        result.collideConnected_ = collideConnected_;
        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
          to_bitField0_ |= 0x00000020;
        }
        if (localAnchorABuilder_ == null) {
          result.localAnchorA_ = localAnchorA_;
        } else {
          result.localAnchorA_ = localAnchorABuilder_.build();
        }
        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
          to_bitField0_ |= 0x00000040;
        }
        if (localAnchorBBuilder_ == null) {
          result.localAnchorB_ = localAnchorB_;
        } else {
          result.localAnchorB_ = localAnchorBBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
          to_bitField0_ |= 0x00000080;
        }
        result.refAngle_ = refAngle_;
        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
          to_bitField0_ |= 0x00000100;
        }
        result.enableLimit_ = enableLimit_;
        if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
          to_bitField0_ |= 0x00000200;
        }
        result.lowerLimit_ = lowerLimit_;
        if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
          to_bitField0_ |= 0x00000400;
        }
        result.upperLimit_ = upperLimit_;
        if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
          to_bitField0_ |= 0x00000800;
        }
        result.enableMotor_ = enableMotor_;
        if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
          to_bitField0_ |= 0x00001000;
        }
        result.motorSpeed_ = motorSpeed_;
        if (((from_bitField0_ & 0x00002000) == 0x00002000)) {
          to_bitField0_ |= 0x00002000;
        }
        result.maxMotorTorque_ = maxMotorTorque_;
        if (((from_bitField0_ & 0x00004000) == 0x00004000)) {
          to_bitField0_ |= 0x00004000;
        }
        if (localAxisABuilder_ == null) {
          result.localAxisA_ = localAxisA_;
        } else {
          result.localAxisA_ = localAxisABuilder_.build();
        }
        if (((from_bitField0_ & 0x00008000) == 0x00008000)) {
          to_bitField0_ |= 0x00008000;
        }
        result.maxMotorForce_ = maxMotorForce_;
        if (((from_bitField0_ & 0x00010000) == 0x00010000)) {
          to_bitField0_ |= 0x00010000;
        }
        result.length_ = length_;
        if (((from_bitField0_ & 0x00020000) == 0x00020000)) {
          to_bitField0_ |= 0x00020000;
        }
        result.frequency_ = frequency_;
        if (((from_bitField0_ & 0x00040000) == 0x00040000)) {
          to_bitField0_ |= 0x00040000;
        }
        result.dampingRatio_ = dampingRatio_;
        if (((from_bitField0_ & 0x00080000) == 0x00080000)) {
          to_bitField0_ |= 0x00080000;
        }
        if (groundAnchorABuilder_ == null) {
          result.groundAnchorA_ = groundAnchorA_;
        } else {
          result.groundAnchorA_ = groundAnchorABuilder_.build();
        }
        if (((from_bitField0_ & 0x00100000) == 0x00100000)) {
          to_bitField0_ |= 0x00100000;
        }
        if (groundAnchorBBuilder_ == null) {
          result.groundAnchorB_ = groundAnchorB_;
        } else {
          result.groundAnchorB_ = groundAnchorBBuilder_.build();
        }
        if (((from_bitField0_ & 0x00200000) == 0x00200000)) {
          to_bitField0_ |= 0x00200000;
        }
        result.lengthA_ = lengthA_;
        if (((from_bitField0_ & 0x00400000) == 0x00400000)) {
          to_bitField0_ |= 0x00400000;
        }
        result.lengthB_ = lengthB_;
        if (((from_bitField0_ & 0x00800000) == 0x00800000)) {
          to_bitField0_ |= 0x00800000;
        }
        result.ratio_ = ratio_;
        if (((from_bitField0_ & 0x01000000) == 0x01000000)) {
          to_bitField0_ |= 0x01000000;
        }
        result.maxLengthA_ = maxLengthA_;
        if (((from_bitField0_ & 0x02000000) == 0x02000000)) {
          to_bitField0_ |= 0x02000000;
        }
        result.maxLengthB_ = maxLengthB_;
        if (((from_bitField0_ & 0x04000000) == 0x04000000)) {
          to_bitField0_ |= 0x04000000;
        }
        if (targetBuilder_ == null) {
          result.target_ = target_;
        } else {
          result.target_ = targetBuilder_.build();
        }
        if (((from_bitField0_ & 0x08000000) == 0x08000000)) {
          to_bitField0_ |= 0x08000000;
        }
        result.maxForce_ = maxForce_;
        if (((from_bitField0_ & 0x10000000) == 0x10000000)) {
          to_bitField0_ |= 0x10000000;
        }
        result.joint1_ = joint1_;
        if (((from_bitField0_ & 0x20000000) == 0x20000000)) {
          to_bitField0_ |= 0x20000000;
        }
        result.joint2_ = joint2_;
        if (((from_bitField0_ & 0x40000000) == 0x40000000)) {
          to_bitField0_ |= 0x40000000;
        }
        result.springFrequency_ = springFrequency_;
        if (((from_bitField0_ & 0x80000000) == 0x80000000)) {
          to_bitField0_ |= 0x80000000;
        }
        result.springDampingRatio_ = springDampingRatio_;
        if (((from_bitField1_ & 0x00000001) == 0x00000001)) {
          to_bitField1_ |= 0x00000001;
        }
        result.maxTorque_ = maxTorque_;
        if (((from_bitField1_ & 0x00000002) == 0x00000002)) {
          to_bitField1_ |= 0x00000002;
        }
        result.maxLength_ = maxLength_;
        if (((bitField1_ & 0x00000004) == 0x00000004)) {
          bodies_ = java.util.Collections.unmodifiableList(bodies_);
          bitField1_ = (bitField1_ & ~0x00000004);
        }
        result.bodies_ = bodies_;
        if (((bitField1_ & 0x00000008) == 0x00000008)) {
          joints_ = java.util.Collections.unmodifiableList(joints_);
          bitField1_ = (bitField1_ & ~0x00000008);
        }
        result.joints_ = joints_;
        if (((from_bitField1_ & 0x00000010) == 0x00000010)) {
          to_bitField1_ |= 0x00000004;
        }
        result.targetVolume_ = targetVolume_;
        result.bitField0_ = to_bitField0_;
        result.bitField1_ = to_bitField1_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.box2d.proto.Box2D.PbJoint) {
          return mergeFrom((org.box2d.proto.Box2D.PbJoint)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.box2d.proto.Box2D.PbJoint other) {
        if (other == org.box2d.proto.Box2D.PbJoint.getDefaultInstance()) return this;
        if (other.hasTag()) {
          setTag(other.getTag());
        }
        if (other.hasType()) {
          setType(other.getType());
        }
        if (other.hasBodyA()) {
          setBodyA(other.getBodyA());
        }
        if (other.hasBodyB()) {
          setBodyB(other.getBodyB());
        }
        if (other.hasCollideConnected()) {
          setCollideConnected(other.getCollideConnected());
        }
        if (other.hasLocalAnchorA()) {
          mergeLocalAnchorA(other.getLocalAnchorA());
        }
        if (other.hasLocalAnchorB()) {
          mergeLocalAnchorB(other.getLocalAnchorB());
        }
        if (other.hasRefAngle()) {
          setRefAngle(other.getRefAngle());
        }
        if (other.hasEnableLimit()) {
          setEnableLimit(other.getEnableLimit());
        }
        if (other.hasLowerLimit()) {
          setLowerLimit(other.getLowerLimit());
        }
        if (other.hasUpperLimit()) {
          setUpperLimit(other.getUpperLimit());
        }
        if (other.hasEnableMotor()) {
          setEnableMotor(other.getEnableMotor());
        }
        if (other.hasMotorSpeed()) {
          setMotorSpeed(other.getMotorSpeed());
        }
        if (other.hasMaxMotorTorque()) {
          setMaxMotorTorque(other.getMaxMotorTorque());
        }
        if (other.hasLocalAxisA()) {
          mergeLocalAxisA(other.getLocalAxisA());
        }
        if (other.hasMaxMotorForce()) {
          setMaxMotorForce(other.getMaxMotorForce());
        }
        if (other.hasLength()) {
          setLength(other.getLength());
        }
        if (other.hasFrequency()) {
          setFrequency(other.getFrequency());
        }
        if (other.hasDampingRatio()) {
          setDampingRatio(other.getDampingRatio());
        }
        if (other.hasGroundAnchorA()) {
          mergeGroundAnchorA(other.getGroundAnchorA());
        }
        if (other.hasGroundAnchorB()) {
          mergeGroundAnchorB(other.getGroundAnchorB());
        }
        if (other.hasLengthA()) {
          setLengthA(other.getLengthA());
        }
        if (other.hasLengthB()) {
          setLengthB(other.getLengthB());
        }
        if (other.hasRatio()) {
          setRatio(other.getRatio());
        }
        if (other.hasMaxLengthA()) {
          setMaxLengthA(other.getMaxLengthA());
        }
        if (other.hasMaxLengthB()) {
          setMaxLengthB(other.getMaxLengthB());
        }
        if (other.hasTarget()) {
          mergeTarget(other.getTarget());
        }
        if (other.hasMaxForce()) {
          setMaxForce(other.getMaxForce());
        }
        if (other.hasJoint1()) {
          setJoint1(other.getJoint1());
        }
        if (other.hasJoint2()) {
          setJoint2(other.getJoint2());
        }
        if (other.hasSpringFrequency()) {
          setSpringFrequency(other.getSpringFrequency());
        }
        if (other.hasSpringDampingRatio()) {
          setSpringDampingRatio(other.getSpringDampingRatio());
        }
        if (other.hasMaxTorque()) {
          setMaxTorque(other.getMaxTorque());
        }
        if (other.hasMaxLength()) {
          setMaxLength(other.getMaxLength());
        }
        if (!other.bodies_.isEmpty()) {
          if (bodies_.isEmpty()) {
            bodies_ = other.bodies_;
            bitField1_ = (bitField1_ & ~0x00000004);
          } else {
            ensureBodiesIsMutable();
            bodies_.addAll(other.bodies_);
          }
          onChanged();
        }
        if (!other.joints_.isEmpty()) {
          if (joints_.isEmpty()) {
            joints_ = other.joints_;
            bitField1_ = (bitField1_ & ~0x00000008);
          } else {
            ensureJointsIsMutable();
            joints_.addAll(other.joints_);
          }
          onChanged();
        }
        if (other.hasTargetVolume()) {
          setTargetVolume(other.getTargetVolume());
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasType()) {
          
          return false;
        }
        if (hasLocalAnchorA()) {
          if (!getLocalAnchorA().isInitialized()) {
            
            return false;
          }
        }
        if (hasLocalAnchorB()) {
          if (!getLocalAnchorB().isInitialized()) {
            
            return false;
          }
        }
        if (hasLocalAxisA()) {
          if (!getLocalAxisA().isInitialized()) {
            
            return false;
          }
        }
        if (hasGroundAnchorA()) {
          if (!getGroundAnchorA().isInitialized()) {
            
            return false;
          }
        }
        if (hasGroundAnchorB()) {
          if (!getGroundAnchorB().isInitialized()) {
            
            return false;
          }
        }
        if (hasTarget()) {
          if (!getTarget().isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              bitField0_ |= 0x00000001;
              tag_ = input.readInt64();
              break;
            }
            case 16: {
              int rawValue = input.readEnum();
              org.box2d.proto.Box2D.PbJointType value = org.box2d.proto.Box2D.PbJointType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(2, rawValue);
              } else {
                bitField0_ |= 0x00000002;
                type_ = value;
              }
              break;
            }
            case 24: {
              bitField0_ |= 0x00000004;
              bodyA_ = input.readInt32();
              break;
            }
            case 32: {
              bitField0_ |= 0x00000008;
              bodyB_ = input.readInt32();
              break;
            }
            case 40: {
              bitField0_ |= 0x00000010;
              collideConnected_ = input.readBool();
              break;
            }
            case 50: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasLocalAnchorA()) {
                subBuilder.mergeFrom(getLocalAnchorA());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setLocalAnchorA(subBuilder.buildPartial());
              break;
            }
            case 58: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasLocalAnchorB()) {
                subBuilder.mergeFrom(getLocalAnchorB());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setLocalAnchorB(subBuilder.buildPartial());
              break;
            }
            case 85: {
              bitField0_ |= 0x00000080;
              refAngle_ = input.readFloat();
              break;
            }
            case 96: {
              bitField0_ |= 0x00000100;
              enableLimit_ = input.readBool();
              break;
            }
            case 109: {
              bitField0_ |= 0x00000200;
              lowerLimit_ = input.readFloat();
              break;
            }
            case 117: {
              bitField0_ |= 0x00000400;
              upperLimit_ = input.readFloat();
              break;
            }
            case 120: {
              bitField0_ |= 0x00000800;
              enableMotor_ = input.readBool();
              break;
            }
            case 133: {
              bitField0_ |= 0x00001000;
              motorSpeed_ = input.readFloat();
              break;
            }
            case 141: {
              bitField0_ |= 0x00002000;
              maxMotorTorque_ = input.readFloat();
              break;
            }
            case 162: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasLocalAxisA()) {
                subBuilder.mergeFrom(getLocalAxisA());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setLocalAxisA(subBuilder.buildPartial());
              break;
            }
            case 173: {
              bitField0_ |= 0x00008000;
              maxMotorForce_ = input.readFloat();
              break;
            }
            case 245: {
              bitField0_ |= 0x00010000;
              length_ = input.readFloat();
              break;
            }
            case 253: {
              bitField0_ |= 0x00020000;
              frequency_ = input.readFloat();
              break;
            }
            case 261: {
              bitField0_ |= 0x00040000;
              dampingRatio_ = input.readFloat();
              break;
            }
            case 322: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasGroundAnchorA()) {
                subBuilder.mergeFrom(getGroundAnchorA());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setGroundAnchorA(subBuilder.buildPartial());
              break;
            }
            case 330: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasGroundAnchorB()) {
                subBuilder.mergeFrom(getGroundAnchorB());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setGroundAnchorB(subBuilder.buildPartial());
              break;
            }
            case 341: {
              bitField0_ |= 0x00200000;
              lengthA_ = input.readFloat();
              break;
            }
            case 349: {
              bitField0_ |= 0x00400000;
              lengthB_ = input.readFloat();
              break;
            }
            case 357: {
              bitField0_ |= 0x00800000;
              ratio_ = input.readFloat();
              break;
            }
            case 365: {
              bitField0_ |= 0x01000000;
              maxLengthA_ = input.readFloat();
              break;
            }
            case 373: {
              bitField0_ |= 0x02000000;
              maxLengthB_ = input.readFloat();
              break;
            }
            case 402: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasTarget()) {
                subBuilder.mergeFrom(getTarget());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setTarget(subBuilder.buildPartial());
              break;
            }
            case 413: {
              bitField0_ |= 0x08000000;
              maxForce_ = input.readFloat();
              break;
            }
            case 488: {
              bitField0_ |= 0x10000000;
              joint1_ = input.readInt32();
              break;
            }
            case 496: {
              bitField0_ |= 0x20000000;
              joint2_ = input.readInt32();
              break;
            }
            case 565: {
              bitField0_ |= 0x40000000;
              springFrequency_ = input.readFloat();
              break;
            }
            case 573: {
              bitField0_ |= 0x80000000;
              springDampingRatio_ = input.readFloat();
              break;
            }
            case 725: {
              bitField1_ |= 0x00000001;
              maxTorque_ = input.readFloat();
              break;
            }
            case 805: {
              bitField1_ |= 0x00000002;
              maxLength_ = input.readFloat();
              break;
            }
            case 880: {
              ensureBodiesIsMutable();
              bodies_.add(input.readInt32());
              break;
            }
            case 882: {
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addBodies(input.readInt32());
              }
              input.popLimit(limit);
              break;
            }
            case 888: {
              ensureJointsIsMutable();
              joints_.add(input.readInt32());
              break;
            }
            case 890: {
              int length = input.readRawVarint32();
              int limit = input.pushLimit(length);
              while (input.getBytesUntilLimit() > 0) {
                addJoints(input.readInt32());
              }
              input.popLimit(limit);
              break;
            }
            case 901: {
              bitField1_ |= 0x00000010;
              targetVolume_ = input.readFloat();
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      private int bitField1_;
      
      // optional int64 tag = 1;
      private long tag_ ;
      public boolean hasTag() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public long getTag() {
        return tag_;
      }
      public Builder setTag(long value) {
        bitField0_ |= 0x00000001;
        tag_ = value;
        onChanged();
        return this;
      }
      public Builder clearTag() {
        bitField0_ = (bitField0_ & ~0x00000001);
        tag_ = 0L;
        onChanged();
        return this;
      }
      
      // required .box2d.PbJointType type = 2;
      private org.box2d.proto.Box2D.PbJointType type_ = org.box2d.proto.Box2D.PbJointType.DISTANCE;
      public boolean hasType() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public org.box2d.proto.Box2D.PbJointType getType() {
        return type_;
      }
      public Builder setType(org.box2d.proto.Box2D.PbJointType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        bitField0_ |= 0x00000002;
        type_ = value;
        onChanged();
        return this;
      }
      public Builder clearType() {
        bitField0_ = (bitField0_ & ~0x00000002);
        type_ = org.box2d.proto.Box2D.PbJointType.DISTANCE;
        onChanged();
        return this;
      }
      
      // optional int32 body_a = 3;
      private int bodyA_ ;
      public boolean hasBodyA() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public int getBodyA() {
        return bodyA_;
      }
      public Builder setBodyA(int value) {
        bitField0_ |= 0x00000004;
        bodyA_ = value;
        onChanged();
        return this;
      }
      public Builder clearBodyA() {
        bitField0_ = (bitField0_ & ~0x00000004);
        bodyA_ = 0;
        onChanged();
        return this;
      }
      
      // optional int32 body_b = 4;
      private int bodyB_ ;
      public boolean hasBodyB() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public int getBodyB() {
        return bodyB_;
      }
      public Builder setBodyB(int value) {
        bitField0_ |= 0x00000008;
        bodyB_ = value;
        onChanged();
        return this;
      }
      public Builder clearBodyB() {
        bitField0_ = (bitField0_ & ~0x00000008);
        bodyB_ = 0;
        onChanged();
        return this;
      }
      
      // optional bool collideConnected = 5;
      private boolean collideConnected_ ;
      public boolean hasCollideConnected() {
        return ((bitField0_ & 0x00000010) == 0x00000010);
      }
      public boolean getCollideConnected() {
        return collideConnected_;
      }
      public Builder setCollideConnected(boolean value) {
        bitField0_ |= 0x00000010;
        collideConnected_ = value;
        onChanged();
        return this;
      }
      public Builder clearCollideConnected() {
        bitField0_ = (bitField0_ & ~0x00000010);
        collideConnected_ = false;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 local_anchor_a = 6;
      private org.box2d.proto.Box2D.PbVec2 localAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> localAnchorABuilder_;
      public boolean hasLocalAnchorA() {
        return ((bitField0_ & 0x00000020) == 0x00000020);
      }
      public org.box2d.proto.Box2D.PbVec2 getLocalAnchorA() {
        if (localAnchorABuilder_ == null) {
          return localAnchorA_;
        } else {
          return localAnchorABuilder_.getMessage();
        }
      }
      public Builder setLocalAnchorA(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAnchorABuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          localAnchorA_ = value;
          onChanged();
        } else {
          localAnchorABuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder setLocalAnchorA(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (localAnchorABuilder_ == null) {
          localAnchorA_ = builderForValue.build();
          onChanged();
        } else {
          localAnchorABuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder mergeLocalAnchorA(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAnchorABuilder_ == null) {
          if (((bitField0_ & 0x00000020) == 0x00000020) &&
              localAnchorA_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            localAnchorA_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(localAnchorA_).mergeFrom(value).buildPartial();
          } else {
            localAnchorA_ = value;
          }
          onChanged();
        } else {
          localAnchorABuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000020;
        return this;
      }
      public Builder clearLocalAnchorA() {
        if (localAnchorABuilder_ == null) {
          localAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          localAnchorABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000020);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getLocalAnchorABuilder() {
        bitField0_ |= 0x00000020;
        onChanged();
        return getLocalAnchorAFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorAOrBuilder() {
        if (localAnchorABuilder_ != null) {
          return localAnchorABuilder_.getMessageOrBuilder();
        } else {
          return localAnchorA_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getLocalAnchorAFieldBuilder() {
        if (localAnchorABuilder_ == null) {
          localAnchorABuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  localAnchorA_,
                  getParentForChildren(),
                  isClean());
          localAnchorA_ = null;
        }
        return localAnchorABuilder_;
      }
      
      // optional .box2d.PbVec2 local_anchor_b = 7;
      private org.box2d.proto.Box2D.PbVec2 localAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> localAnchorBBuilder_;
      public boolean hasLocalAnchorB() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public org.box2d.proto.Box2D.PbVec2 getLocalAnchorB() {
        if (localAnchorBBuilder_ == null) {
          return localAnchorB_;
        } else {
          return localAnchorBBuilder_.getMessage();
        }
      }
      public Builder setLocalAnchorB(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAnchorBBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          localAnchorB_ = value;
          onChanged();
        } else {
          localAnchorBBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder setLocalAnchorB(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (localAnchorBBuilder_ == null) {
          localAnchorB_ = builderForValue.build();
          onChanged();
        } else {
          localAnchorBBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder mergeLocalAnchorB(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAnchorBBuilder_ == null) {
          if (((bitField0_ & 0x00000040) == 0x00000040) &&
              localAnchorB_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            localAnchorB_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(localAnchorB_).mergeFrom(value).buildPartial();
          } else {
            localAnchorB_ = value;
          }
          onChanged();
        } else {
          localAnchorBBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder clearLocalAnchorB() {
        if (localAnchorBBuilder_ == null) {
          localAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          localAnchorBBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getLocalAnchorBBuilder() {
        bitField0_ |= 0x00000040;
        onChanged();
        return getLocalAnchorBFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAnchorBOrBuilder() {
        if (localAnchorBBuilder_ != null) {
          return localAnchorBBuilder_.getMessageOrBuilder();
        } else {
          return localAnchorB_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getLocalAnchorBFieldBuilder() {
        if (localAnchorBBuilder_ == null) {
          localAnchorBBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  localAnchorB_,
                  getParentForChildren(),
                  isClean());
          localAnchorB_ = null;
        }
        return localAnchorBBuilder_;
      }
      
      // optional float ref_angle = 10;
      private float refAngle_ ;
      public boolean hasRefAngle() {
        return ((bitField0_ & 0x00000080) == 0x00000080);
      }
      public float getRefAngle() {
        return refAngle_;
      }
      public Builder setRefAngle(float value) {
        bitField0_ |= 0x00000080;
        refAngle_ = value;
        onChanged();
        return this;
      }
      public Builder clearRefAngle() {
        bitField0_ = (bitField0_ & ~0x00000080);
        refAngle_ = 0F;
        onChanged();
        return this;
      }
      
      // optional bool enable_limit = 12;
      private boolean enableLimit_ ;
      public boolean hasEnableLimit() {
        return ((bitField0_ & 0x00000100) == 0x00000100);
      }
      public boolean getEnableLimit() {
        return enableLimit_;
      }
      public Builder setEnableLimit(boolean value) {
        bitField0_ |= 0x00000100;
        enableLimit_ = value;
        onChanged();
        return this;
      }
      public Builder clearEnableLimit() {
        bitField0_ = (bitField0_ & ~0x00000100);
        enableLimit_ = false;
        onChanged();
        return this;
      }
      
      // optional float lower_limit = 13;
      private float lowerLimit_ ;
      public boolean hasLowerLimit() {
        return ((bitField0_ & 0x00000200) == 0x00000200);
      }
      public float getLowerLimit() {
        return lowerLimit_;
      }
      public Builder setLowerLimit(float value) {
        bitField0_ |= 0x00000200;
        lowerLimit_ = value;
        onChanged();
        return this;
      }
      public Builder clearLowerLimit() {
        bitField0_ = (bitField0_ & ~0x00000200);
        lowerLimit_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float upper_limit = 14;
      private float upperLimit_ ;
      public boolean hasUpperLimit() {
        return ((bitField0_ & 0x00000400) == 0x00000400);
      }
      public float getUpperLimit() {
        return upperLimit_;
      }
      public Builder setUpperLimit(float value) {
        bitField0_ |= 0x00000400;
        upperLimit_ = value;
        onChanged();
        return this;
      }
      public Builder clearUpperLimit() {
        bitField0_ = (bitField0_ & ~0x00000400);
        upperLimit_ = 0F;
        onChanged();
        return this;
      }
      
      // optional bool enable_motor = 15;
      private boolean enableMotor_ ;
      public boolean hasEnableMotor() {
        return ((bitField0_ & 0x00000800) == 0x00000800);
      }
      public boolean getEnableMotor() {
        return enableMotor_;
      }
      public Builder setEnableMotor(boolean value) {
        bitField0_ |= 0x00000800;
        enableMotor_ = value;
        onChanged();
        return this;
      }
      public Builder clearEnableMotor() {
        bitField0_ = (bitField0_ & ~0x00000800);
        enableMotor_ = false;
        onChanged();
        return this;
      }
      
      // optional float motor_speed = 16;
      private float motorSpeed_ ;
      public boolean hasMotorSpeed() {
        return ((bitField0_ & 0x00001000) == 0x00001000);
      }
      public float getMotorSpeed() {
        return motorSpeed_;
      }
      public Builder setMotorSpeed(float value) {
        bitField0_ |= 0x00001000;
        motorSpeed_ = value;
        onChanged();
        return this;
      }
      public Builder clearMotorSpeed() {
        bitField0_ = (bitField0_ & ~0x00001000);
        motorSpeed_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float max_motor_torque = 17;
      private float maxMotorTorque_ ;
      public boolean hasMaxMotorTorque() {
        return ((bitField0_ & 0x00002000) == 0x00002000);
      }
      public float getMaxMotorTorque() {
        return maxMotorTorque_;
      }
      public Builder setMaxMotorTorque(float value) {
        bitField0_ |= 0x00002000;
        maxMotorTorque_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxMotorTorque() {
        bitField0_ = (bitField0_ & ~0x00002000);
        maxMotorTorque_ = 0F;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 local_axis_a = 20;
      private org.box2d.proto.Box2D.PbVec2 localAxisA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> localAxisABuilder_;
      public boolean hasLocalAxisA() {
        return ((bitField0_ & 0x00004000) == 0x00004000);
      }
      public org.box2d.proto.Box2D.PbVec2 getLocalAxisA() {
        if (localAxisABuilder_ == null) {
          return localAxisA_;
        } else {
          return localAxisABuilder_.getMessage();
        }
      }
      public Builder setLocalAxisA(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAxisABuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          localAxisA_ = value;
          onChanged();
        } else {
          localAxisABuilder_.setMessage(value);
        }
        bitField0_ |= 0x00004000;
        return this;
      }
      public Builder setLocalAxisA(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (localAxisABuilder_ == null) {
          localAxisA_ = builderForValue.build();
          onChanged();
        } else {
          localAxisABuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00004000;
        return this;
      }
      public Builder mergeLocalAxisA(org.box2d.proto.Box2D.PbVec2 value) {
        if (localAxisABuilder_ == null) {
          if (((bitField0_ & 0x00004000) == 0x00004000) &&
              localAxisA_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            localAxisA_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(localAxisA_).mergeFrom(value).buildPartial();
          } else {
            localAxisA_ = value;
          }
          onChanged();
        } else {
          localAxisABuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00004000;
        return this;
      }
      public Builder clearLocalAxisA() {
        if (localAxisABuilder_ == null) {
          localAxisA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          localAxisABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00004000);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getLocalAxisABuilder() {
        bitField0_ |= 0x00004000;
        onChanged();
        return getLocalAxisAFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getLocalAxisAOrBuilder() {
        if (localAxisABuilder_ != null) {
          return localAxisABuilder_.getMessageOrBuilder();
        } else {
          return localAxisA_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getLocalAxisAFieldBuilder() {
        if (localAxisABuilder_ == null) {
          localAxisABuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  localAxisA_,
                  getParentForChildren(),
                  isClean());
          localAxisA_ = null;
        }
        return localAxisABuilder_;
      }
      
      // optional float max_motor_force = 21;
      private float maxMotorForce_ ;
      public boolean hasMaxMotorForce() {
        return ((bitField0_ & 0x00008000) == 0x00008000);
      }
      public float getMaxMotorForce() {
        return maxMotorForce_;
      }
      public Builder setMaxMotorForce(float value) {
        bitField0_ |= 0x00008000;
        maxMotorForce_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxMotorForce() {
        bitField0_ = (bitField0_ & ~0x00008000);
        maxMotorForce_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float length = 30;
      private float length_ ;
      public boolean hasLength() {
        return ((bitField0_ & 0x00010000) == 0x00010000);
      }
      public float getLength() {
        return length_;
      }
      public Builder setLength(float value) {
        bitField0_ |= 0x00010000;
        length_ = value;
        onChanged();
        return this;
      }
      public Builder clearLength() {
        bitField0_ = (bitField0_ & ~0x00010000);
        length_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float frequency = 31;
      private float frequency_ ;
      public boolean hasFrequency() {
        return ((bitField0_ & 0x00020000) == 0x00020000);
      }
      public float getFrequency() {
        return frequency_;
      }
      public Builder setFrequency(float value) {
        bitField0_ |= 0x00020000;
        frequency_ = value;
        onChanged();
        return this;
      }
      public Builder clearFrequency() {
        bitField0_ = (bitField0_ & ~0x00020000);
        frequency_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float damping_ratio = 32;
      private float dampingRatio_ ;
      public boolean hasDampingRatio() {
        return ((bitField0_ & 0x00040000) == 0x00040000);
      }
      public float getDampingRatio() {
        return dampingRatio_;
      }
      public Builder setDampingRatio(float value) {
        bitField0_ |= 0x00040000;
        dampingRatio_ = value;
        onChanged();
        return this;
      }
      public Builder clearDampingRatio() {
        bitField0_ = (bitField0_ & ~0x00040000);
        dampingRatio_ = 0F;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 ground_anchor_a = 40;
      private org.box2d.proto.Box2D.PbVec2 groundAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> groundAnchorABuilder_;
      public boolean hasGroundAnchorA() {
        return ((bitField0_ & 0x00080000) == 0x00080000);
      }
      public org.box2d.proto.Box2D.PbVec2 getGroundAnchorA() {
        if (groundAnchorABuilder_ == null) {
          return groundAnchorA_;
        } else {
          return groundAnchorABuilder_.getMessage();
        }
      }
      public Builder setGroundAnchorA(org.box2d.proto.Box2D.PbVec2 value) {
        if (groundAnchorABuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          groundAnchorA_ = value;
          onChanged();
        } else {
          groundAnchorABuilder_.setMessage(value);
        }
        bitField0_ |= 0x00080000;
        return this;
      }
      public Builder setGroundAnchorA(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (groundAnchorABuilder_ == null) {
          groundAnchorA_ = builderForValue.build();
          onChanged();
        } else {
          groundAnchorABuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00080000;
        return this;
      }
      public Builder mergeGroundAnchorA(org.box2d.proto.Box2D.PbVec2 value) {
        if (groundAnchorABuilder_ == null) {
          if (((bitField0_ & 0x00080000) == 0x00080000) &&
              groundAnchorA_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            groundAnchorA_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(groundAnchorA_).mergeFrom(value).buildPartial();
          } else {
            groundAnchorA_ = value;
          }
          onChanged();
        } else {
          groundAnchorABuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00080000;
        return this;
      }
      public Builder clearGroundAnchorA() {
        if (groundAnchorABuilder_ == null) {
          groundAnchorA_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          groundAnchorABuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00080000);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getGroundAnchorABuilder() {
        bitField0_ |= 0x00080000;
        onChanged();
        return getGroundAnchorAFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorAOrBuilder() {
        if (groundAnchorABuilder_ != null) {
          return groundAnchorABuilder_.getMessageOrBuilder();
        } else {
          return groundAnchorA_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getGroundAnchorAFieldBuilder() {
        if (groundAnchorABuilder_ == null) {
          groundAnchorABuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  groundAnchorA_,
                  getParentForChildren(),
                  isClean());
          groundAnchorA_ = null;
        }
        return groundAnchorABuilder_;
      }
      
      // optional .box2d.PbVec2 ground_anchor_b = 41;
      private org.box2d.proto.Box2D.PbVec2 groundAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> groundAnchorBBuilder_;
      public boolean hasGroundAnchorB() {
        return ((bitField0_ & 0x00100000) == 0x00100000);
      }
      public org.box2d.proto.Box2D.PbVec2 getGroundAnchorB() {
        if (groundAnchorBBuilder_ == null) {
          return groundAnchorB_;
        } else {
          return groundAnchorBBuilder_.getMessage();
        }
      }
      public Builder setGroundAnchorB(org.box2d.proto.Box2D.PbVec2 value) {
        if (groundAnchorBBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          groundAnchorB_ = value;
          onChanged();
        } else {
          groundAnchorBBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00100000;
        return this;
      }
      public Builder setGroundAnchorB(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (groundAnchorBBuilder_ == null) {
          groundAnchorB_ = builderForValue.build();
          onChanged();
        } else {
          groundAnchorBBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00100000;
        return this;
      }
      public Builder mergeGroundAnchorB(org.box2d.proto.Box2D.PbVec2 value) {
        if (groundAnchorBBuilder_ == null) {
          if (((bitField0_ & 0x00100000) == 0x00100000) &&
              groundAnchorB_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            groundAnchorB_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(groundAnchorB_).mergeFrom(value).buildPartial();
          } else {
            groundAnchorB_ = value;
          }
          onChanged();
        } else {
          groundAnchorBBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00100000;
        return this;
      }
      public Builder clearGroundAnchorB() {
        if (groundAnchorBBuilder_ == null) {
          groundAnchorB_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          groundAnchorBBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00100000);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getGroundAnchorBBuilder() {
        bitField0_ |= 0x00100000;
        onChanged();
        return getGroundAnchorBFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getGroundAnchorBOrBuilder() {
        if (groundAnchorBBuilder_ != null) {
          return groundAnchorBBuilder_.getMessageOrBuilder();
        } else {
          return groundAnchorB_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getGroundAnchorBFieldBuilder() {
        if (groundAnchorBBuilder_ == null) {
          groundAnchorBBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  groundAnchorB_,
                  getParentForChildren(),
                  isClean());
          groundAnchorB_ = null;
        }
        return groundAnchorBBuilder_;
      }
      
      // optional float length_a = 42;
      private float lengthA_ ;
      public boolean hasLengthA() {
        return ((bitField0_ & 0x00200000) == 0x00200000);
      }
      public float getLengthA() {
        return lengthA_;
      }
      public Builder setLengthA(float value) {
        bitField0_ |= 0x00200000;
        lengthA_ = value;
        onChanged();
        return this;
      }
      public Builder clearLengthA() {
        bitField0_ = (bitField0_ & ~0x00200000);
        lengthA_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float length_b = 43;
      private float lengthB_ ;
      public boolean hasLengthB() {
        return ((bitField0_ & 0x00400000) == 0x00400000);
      }
      public float getLengthB() {
        return lengthB_;
      }
      public Builder setLengthB(float value) {
        bitField0_ |= 0x00400000;
        lengthB_ = value;
        onChanged();
        return this;
      }
      public Builder clearLengthB() {
        bitField0_ = (bitField0_ & ~0x00400000);
        lengthB_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float ratio = 44;
      private float ratio_ ;
      public boolean hasRatio() {
        return ((bitField0_ & 0x00800000) == 0x00800000);
      }
      public float getRatio() {
        return ratio_;
      }
      public Builder setRatio(float value) {
        bitField0_ |= 0x00800000;
        ratio_ = value;
        onChanged();
        return this;
      }
      public Builder clearRatio() {
        bitField0_ = (bitField0_ & ~0x00800000);
        ratio_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float max_length_a = 45;
      private float maxLengthA_ ;
      public boolean hasMaxLengthA() {
        return ((bitField0_ & 0x01000000) == 0x01000000);
      }
      public float getMaxLengthA() {
        return maxLengthA_;
      }
      public Builder setMaxLengthA(float value) {
        bitField0_ |= 0x01000000;
        maxLengthA_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxLengthA() {
        bitField0_ = (bitField0_ & ~0x01000000);
        maxLengthA_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float max_length_b = 46;
      private float maxLengthB_ ;
      public boolean hasMaxLengthB() {
        return ((bitField0_ & 0x02000000) == 0x02000000);
      }
      public float getMaxLengthB() {
        return maxLengthB_;
      }
      public Builder setMaxLengthB(float value) {
        bitField0_ |= 0x02000000;
        maxLengthB_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxLengthB() {
        bitField0_ = (bitField0_ & ~0x02000000);
        maxLengthB_ = 0F;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 target = 50;
      private org.box2d.proto.Box2D.PbVec2 target_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> targetBuilder_;
      public boolean hasTarget() {
        return ((bitField0_ & 0x04000000) == 0x04000000);
      }
      public org.box2d.proto.Box2D.PbVec2 getTarget() {
        if (targetBuilder_ == null) {
          return target_;
        } else {
          return targetBuilder_.getMessage();
        }
      }
      public Builder setTarget(org.box2d.proto.Box2D.PbVec2 value) {
        if (targetBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          target_ = value;
          onChanged();
        } else {
          targetBuilder_.setMessage(value);
        }
        bitField0_ |= 0x04000000;
        return this;
      }
      public Builder setTarget(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (targetBuilder_ == null) {
          target_ = builderForValue.build();
          onChanged();
        } else {
          targetBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x04000000;
        return this;
      }
      public Builder mergeTarget(org.box2d.proto.Box2D.PbVec2 value) {
        if (targetBuilder_ == null) {
          if (((bitField0_ & 0x04000000) == 0x04000000) &&
              target_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            target_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(target_).mergeFrom(value).buildPartial();
          } else {
            target_ = value;
          }
          onChanged();
        } else {
          targetBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x04000000;
        return this;
      }
      public Builder clearTarget() {
        if (targetBuilder_ == null) {
          target_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          targetBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x04000000);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getTargetBuilder() {
        bitField0_ |= 0x04000000;
        onChanged();
        return getTargetFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getTargetOrBuilder() {
        if (targetBuilder_ != null) {
          return targetBuilder_.getMessageOrBuilder();
        } else {
          return target_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getTargetFieldBuilder() {
        if (targetBuilder_ == null) {
          targetBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  target_,
                  getParentForChildren(),
                  isClean());
          target_ = null;
        }
        return targetBuilder_;
      }
      
      // optional float max_force = 51;
      private float maxForce_ ;
      public boolean hasMaxForce() {
        return ((bitField0_ & 0x08000000) == 0x08000000);
      }
      public float getMaxForce() {
        return maxForce_;
      }
      public Builder setMaxForce(float value) {
        bitField0_ |= 0x08000000;
        maxForce_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxForce() {
        bitField0_ = (bitField0_ & ~0x08000000);
        maxForce_ = 0F;
        onChanged();
        return this;
      }
      
      // optional int32 joint1 = 61;
      private int joint1_ ;
      public boolean hasJoint1() {
        return ((bitField0_ & 0x10000000) == 0x10000000);
      }
      public int getJoint1() {
        return joint1_;
      }
      public Builder setJoint1(int value) {
        bitField0_ |= 0x10000000;
        joint1_ = value;
        onChanged();
        return this;
      }
      public Builder clearJoint1() {
        bitField0_ = (bitField0_ & ~0x10000000);
        joint1_ = 0;
        onChanged();
        return this;
      }
      
      // optional int32 joint2 = 62;
      private int joint2_ ;
      public boolean hasJoint2() {
        return ((bitField0_ & 0x20000000) == 0x20000000);
      }
      public int getJoint2() {
        return joint2_;
      }
      public Builder setJoint2(int value) {
        bitField0_ |= 0x20000000;
        joint2_ = value;
        onChanged();
        return this;
      }
      public Builder clearJoint2() {
        bitField0_ = (bitField0_ & ~0x20000000);
        joint2_ = 0;
        onChanged();
        return this;
      }
      
      // optional float spring_frequency = 70;
      private float springFrequency_ ;
      public boolean hasSpringFrequency() {
        return ((bitField0_ & 0x40000000) == 0x40000000);
      }
      public float getSpringFrequency() {
        return springFrequency_;
      }
      public Builder setSpringFrequency(float value) {
        bitField0_ |= 0x40000000;
        springFrequency_ = value;
        onChanged();
        return this;
      }
      public Builder clearSpringFrequency() {
        bitField0_ = (bitField0_ & ~0x40000000);
        springFrequency_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float spring_damping_ratio = 71;
      private float springDampingRatio_ ;
      public boolean hasSpringDampingRatio() {
        return ((bitField0_ & 0x80000000) == 0x80000000);
      }
      public float getSpringDampingRatio() {
        return springDampingRatio_;
      }
      public Builder setSpringDampingRatio(float value) {
        bitField0_ |= 0x80000000;
        springDampingRatio_ = value;
        onChanged();
        return this;
      }
      public Builder clearSpringDampingRatio() {
        bitField0_ = (bitField0_ & ~0x80000000);
        springDampingRatio_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float max_torque = 90;
      private float maxTorque_ ;
      public boolean hasMaxTorque() {
        return ((bitField1_ & 0x00000001) == 0x00000001);
      }
      public float getMaxTorque() {
        return maxTorque_;
      }
      public Builder setMaxTorque(float value) {
        bitField1_ |= 0x00000001;
        maxTorque_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxTorque() {
        bitField1_ = (bitField1_ & ~0x00000001);
        maxTorque_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float max_length = 100;
      private float maxLength_ ;
      public boolean hasMaxLength() {
        return ((bitField1_ & 0x00000002) == 0x00000002);
      }
      public float getMaxLength() {
        return maxLength_;
      }
      public Builder setMaxLength(float value) {
        bitField1_ |= 0x00000002;
        maxLength_ = value;
        onChanged();
        return this;
      }
      public Builder clearMaxLength() {
        bitField1_ = (bitField1_ & ~0x00000002);
        maxLength_ = 0F;
        onChanged();
        return this;
      }
      
      // repeated int32 bodies = 110;
      private java.util.List<java.lang.Integer> bodies_ = java.util.Collections.emptyList();;
      private void ensureBodiesIsMutable() {
        if (!((bitField1_ & 0x00000004) == 0x00000004)) {
          bodies_ = new java.util.ArrayList<java.lang.Integer>(bodies_);
          bitField1_ |= 0x00000004;
         }
      }
      public java.util.List<java.lang.Integer>
          getBodiesList() {
        return java.util.Collections.unmodifiableList(bodies_);
      }
      public int getBodiesCount() {
        return bodies_.size();
      }
      public int getBodies(int index) {
        return bodies_.get(index);
      }
      public Builder setBodies(
          int index, int value) {
        ensureBodiesIsMutable();
        bodies_.set(index, value);
        onChanged();
        return this;
      }
      public Builder addBodies(int value) {
        ensureBodiesIsMutable();
        bodies_.add(value);
        onChanged();
        return this;
      }
      public Builder addAllBodies(
          java.lang.Iterable<? extends java.lang.Integer> values) {
        ensureBodiesIsMutable();
        super.addAll(values, bodies_);
        onChanged();
        return this;
      }
      public Builder clearBodies() {
        bodies_ = java.util.Collections.emptyList();;
        bitField1_ = (bitField1_ & ~0x00000004);
        onChanged();
        return this;
      }
      
      // repeated int32 joints = 111;
      private java.util.List<java.lang.Integer> joints_ = java.util.Collections.emptyList();;
      private void ensureJointsIsMutable() {
        if (!((bitField1_ & 0x00000008) == 0x00000008)) {
          joints_ = new java.util.ArrayList<java.lang.Integer>(joints_);
          bitField1_ |= 0x00000008;
         }
      }
      public java.util.List<java.lang.Integer>
          getJointsList() {
        return java.util.Collections.unmodifiableList(joints_);
      }
      public int getJointsCount() {
        return joints_.size();
      }
      public int getJoints(int index) {
        return joints_.get(index);
      }
      public Builder setJoints(
          int index, int value) {
        ensureJointsIsMutable();
        joints_.set(index, value);
        onChanged();
        return this;
      }
      public Builder addJoints(int value) {
        ensureJointsIsMutable();
        joints_.add(value);
        onChanged();
        return this;
      }
      public Builder addAllJoints(
          java.lang.Iterable<? extends java.lang.Integer> values) {
        ensureJointsIsMutable();
        super.addAll(values, joints_);
        onChanged();
        return this;
      }
      public Builder clearJoints() {
        joints_ = java.util.Collections.emptyList();;
        bitField1_ = (bitField1_ & ~0x00000008);
        onChanged();
        return this;
      }
      
      // optional float target_volume = 112;
      private float targetVolume_ ;
      public boolean hasTargetVolume() {
        return ((bitField1_ & 0x00000010) == 0x00000010);
      }
      public float getTargetVolume() {
        return targetVolume_;
      }
      public Builder setTargetVolume(float value) {
        bitField1_ |= 0x00000010;
        targetVolume_ = value;
        onChanged();
        return this;
      }
      public Builder clearTargetVolume() {
        bitField1_ = (bitField1_ & ~0x00000010);
        targetVolume_ = 0F;
        onChanged();
        return this;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbJoint)
    }
    
    static {
      defaultInstance = new PbJoint(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbJoint)
  }
  
  public interface PbBodyOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional int64 tag = 1;
    boolean hasTag();
    long getTag();
    
    // required .box2d.PbBodyType type = 2;
    boolean hasType();
    org.box2d.proto.Box2D.PbBodyType getType();
    
    // optional .box2d.PbVec2 position = 10;
    boolean hasPosition();
    org.box2d.proto.Box2D.PbVec2 getPosition();
    org.box2d.proto.Box2D.PbVec2OrBuilder getPositionOrBuilder();
    
    // optional float angle = 11;
    boolean hasAngle();
    float getAngle();
    
    // optional .box2d.PbVec2 linear_velocity = 12;
    boolean hasLinearVelocity();
    org.box2d.proto.Box2D.PbVec2 getLinearVelocity();
    org.box2d.proto.Box2D.PbVec2OrBuilder getLinearVelocityOrBuilder();
    
    // optional float angular_velocity = 13;
    boolean hasAngularVelocity();
    float getAngularVelocity();
    
    // optional .box2d.PbVec2 force = 14;
    boolean hasForce();
    org.box2d.proto.Box2D.PbVec2 getForce();
    org.box2d.proto.Box2D.PbVec2OrBuilder getForceOrBuilder();
    
    // optional float torque = 15;
    boolean hasTorque();
    float getTorque();
    
    // optional float mass = 16;
    boolean hasMass();
    float getMass();
    
    // optional float I = 17;
    boolean hasI();
    float getI();
    
    // optional float linear_damping = 50;
    boolean hasLinearDamping();
    float getLinearDamping();
    
    // optional float angular_damping = 51;
    boolean hasAngularDamping();
    float getAngularDamping();
    
    // optional float gravity_scale = 52;
    boolean hasGravityScale();
    float getGravityScale();
    
    // optional bool bullet = 53;
    boolean hasBullet();
    boolean getBullet();
    
    // optional bool allow_sleep = 54;
    boolean hasAllowSleep();
    boolean getAllowSleep();
    
    // optional bool awake = 55;
    boolean hasAwake();
    boolean getAwake();
    
    // optional bool active = 56;
    boolean hasActive();
    boolean getActive();
    
    // optional bool fixed_rotation = 57;
    boolean hasFixedRotation();
    boolean getFixedRotation();
    
    // repeated .box2d.PbFixture fixtures = 100;
    java.util.List<org.box2d.proto.Box2D.PbFixture> 
        getFixturesList();
    org.box2d.proto.Box2D.PbFixture getFixtures(int index);
    int getFixturesCount();
    java.util.List<? extends org.box2d.proto.Box2D.PbFixtureOrBuilder> 
        getFixturesOrBuilderList();
    org.box2d.proto.Box2D.PbFixtureOrBuilder getFixturesOrBuilder(
        int index);
  }
  public static final class PbBody extends
      com.google.protobuf.GeneratedMessage
      implements PbBodyOrBuilder {
    // Use PbBody.newBuilder() to construct.
    private PbBody(Builder builder) {
      super(builder);
    }
    private PbBody(boolean noInit) {}
    
    private static final PbBody defaultInstance;
    public static PbBody getDefaultInstance() {
      return defaultInstance;
    }
    
    public PbBody getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbBody_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbBody_fieldAccessorTable;
    }
    
    private int bitField0_;
    // optional int64 tag = 1;
    public static final int TAG_FIELD_NUMBER = 1;
    private long tag_;
    public boolean hasTag() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public long getTag() {
      return tag_;
    }
    
    // required .box2d.PbBodyType type = 2;
    public static final int TYPE_FIELD_NUMBER = 2;
    private org.box2d.proto.Box2D.PbBodyType type_;
    public boolean hasType() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public org.box2d.proto.Box2D.PbBodyType getType() {
      return type_;
    }
    
    // optional .box2d.PbVec2 position = 10;
    public static final int POSITION_FIELD_NUMBER = 10;
    private org.box2d.proto.Box2D.PbVec2 position_;
    public boolean hasPosition() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public org.box2d.proto.Box2D.PbVec2 getPosition() {
      return position_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getPositionOrBuilder() {
      return position_;
    }
    
    // optional float angle = 11;
    public static final int ANGLE_FIELD_NUMBER = 11;
    private float angle_;
    public boolean hasAngle() {
      return ((bitField0_ & 0x00000008) == 0x00000008);
    }
    public float getAngle() {
      return angle_;
    }
    
    // optional .box2d.PbVec2 linear_velocity = 12;
    public static final int LINEAR_VELOCITY_FIELD_NUMBER = 12;
    private org.box2d.proto.Box2D.PbVec2 linearVelocity_;
    public boolean hasLinearVelocity() {
      return ((bitField0_ & 0x00000010) == 0x00000010);
    }
    public org.box2d.proto.Box2D.PbVec2 getLinearVelocity() {
      return linearVelocity_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getLinearVelocityOrBuilder() {
      return linearVelocity_;
    }
    
    // optional float angular_velocity = 13;
    public static final int ANGULAR_VELOCITY_FIELD_NUMBER = 13;
    private float angularVelocity_;
    public boolean hasAngularVelocity() {
      return ((bitField0_ & 0x00000020) == 0x00000020);
    }
    public float getAngularVelocity() {
      return angularVelocity_;
    }
    
    // optional .box2d.PbVec2 force = 14;
    public static final int FORCE_FIELD_NUMBER = 14;
    private org.box2d.proto.Box2D.PbVec2 force_;
    public boolean hasForce() {
      return ((bitField0_ & 0x00000040) == 0x00000040);
    }
    public org.box2d.proto.Box2D.PbVec2 getForce() {
      return force_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getForceOrBuilder() {
      return force_;
    }
    
    // optional float torque = 15;
    public static final int TORQUE_FIELD_NUMBER = 15;
    private float torque_;
    public boolean hasTorque() {
      return ((bitField0_ & 0x00000080) == 0x00000080);
    }
    public float getTorque() {
      return torque_;
    }
    
    // optional float mass = 16;
    public static final int MASS_FIELD_NUMBER = 16;
    private float mass_;
    public boolean hasMass() {
      return ((bitField0_ & 0x00000100) == 0x00000100);
    }
    public float getMass() {
      return mass_;
    }
    
    // optional float I = 17;
    public static final int I_FIELD_NUMBER = 17;
    private float i_;
    public boolean hasI() {
      return ((bitField0_ & 0x00000200) == 0x00000200);
    }
    public float getI() {
      return i_;
    }
    
    // optional float linear_damping = 50;
    public static final int LINEAR_DAMPING_FIELD_NUMBER = 50;
    private float linearDamping_;
    public boolean hasLinearDamping() {
      return ((bitField0_ & 0x00000400) == 0x00000400);
    }
    public float getLinearDamping() {
      return linearDamping_;
    }
    
    // optional float angular_damping = 51;
    public static final int ANGULAR_DAMPING_FIELD_NUMBER = 51;
    private float angularDamping_;
    public boolean hasAngularDamping() {
      return ((bitField0_ & 0x00000800) == 0x00000800);
    }
    public float getAngularDamping() {
      return angularDamping_;
    }
    
    // optional float gravity_scale = 52;
    public static final int GRAVITY_SCALE_FIELD_NUMBER = 52;
    private float gravityScale_;
    public boolean hasGravityScale() {
      return ((bitField0_ & 0x00001000) == 0x00001000);
    }
    public float getGravityScale() {
      return gravityScale_;
    }
    
    // optional bool bullet = 53;
    public static final int BULLET_FIELD_NUMBER = 53;
    private boolean bullet_;
    public boolean hasBullet() {
      return ((bitField0_ & 0x00002000) == 0x00002000);
    }
    public boolean getBullet() {
      return bullet_;
    }
    
    // optional bool allow_sleep = 54;
    public static final int ALLOW_SLEEP_FIELD_NUMBER = 54;
    private boolean allowSleep_;
    public boolean hasAllowSleep() {
      return ((bitField0_ & 0x00004000) == 0x00004000);
    }
    public boolean getAllowSleep() {
      return allowSleep_;
    }
    
    // optional bool awake = 55;
    public static final int AWAKE_FIELD_NUMBER = 55;
    private boolean awake_;
    public boolean hasAwake() {
      return ((bitField0_ & 0x00008000) == 0x00008000);
    }
    public boolean getAwake() {
      return awake_;
    }
    
    // optional bool active = 56;
    public static final int ACTIVE_FIELD_NUMBER = 56;
    private boolean active_;
    public boolean hasActive() {
      return ((bitField0_ & 0x00010000) == 0x00010000);
    }
    public boolean getActive() {
      return active_;
    }
    
    // optional bool fixed_rotation = 57;
    public static final int FIXED_ROTATION_FIELD_NUMBER = 57;
    private boolean fixedRotation_;
    public boolean hasFixedRotation() {
      return ((bitField0_ & 0x00020000) == 0x00020000);
    }
    public boolean getFixedRotation() {
      return fixedRotation_;
    }
    
    // repeated .box2d.PbFixture fixtures = 100;
    public static final int FIXTURES_FIELD_NUMBER = 100;
    private java.util.List<org.box2d.proto.Box2D.PbFixture> fixtures_;
    public java.util.List<org.box2d.proto.Box2D.PbFixture> getFixturesList() {
      return fixtures_;
    }
    public java.util.List<? extends org.box2d.proto.Box2D.PbFixtureOrBuilder> 
        getFixturesOrBuilderList() {
      return fixtures_;
    }
    public int getFixturesCount() {
      return fixtures_.size();
    }
    public org.box2d.proto.Box2D.PbFixture getFixtures(int index) {
      return fixtures_.get(index);
    }
    public org.box2d.proto.Box2D.PbFixtureOrBuilder getFixturesOrBuilder(
        int index) {
      return fixtures_.get(index);
    }
    
    private void initFields() {
      tag_ = 0L;
      type_ = org.box2d.proto.Box2D.PbBodyType.STATIC;
      position_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      angle_ = 0F;
      linearVelocity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      angularVelocity_ = 0F;
      force_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      torque_ = 0F;
      mass_ = 0F;
      i_ = 0F;
      linearDamping_ = 0F;
      angularDamping_ = 0F;
      gravityScale_ = 0F;
      bullet_ = false;
      allowSleep_ = false;
      awake_ = false;
      active_ = false;
      fixedRotation_ = false;
      fixtures_ = java.util.Collections.emptyList();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (!hasType()) {
        memoizedIsInitialized = 0;
        return false;
      }
      if (hasPosition()) {
        if (!getPosition().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasLinearVelocity()) {
        if (!getLinearVelocity().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      if (hasForce()) {
        if (!getForce().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getFixturesCount(); i++) {
        if (!getFixtures(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeInt64(1, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeEnum(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeMessage(10, position_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeFloat(11, angle_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeMessage(12, linearVelocity_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        output.writeFloat(13, angularVelocity_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        output.writeMessage(14, force_);
      }
      if (((bitField0_ & 0x00000080) == 0x00000080)) {
        output.writeFloat(15, torque_);
      }
      if (((bitField0_ & 0x00000100) == 0x00000100)) {
        output.writeFloat(16, mass_);
      }
      if (((bitField0_ & 0x00000200) == 0x00000200)) {
        output.writeFloat(17, i_);
      }
      if (((bitField0_ & 0x00000400) == 0x00000400)) {
        output.writeFloat(50, linearDamping_);
      }
      if (((bitField0_ & 0x00000800) == 0x00000800)) {
        output.writeFloat(51, angularDamping_);
      }
      if (((bitField0_ & 0x00001000) == 0x00001000)) {
        output.writeFloat(52, gravityScale_);
      }
      if (((bitField0_ & 0x00002000) == 0x00002000)) {
        output.writeBool(53, bullet_);
      }
      if (((bitField0_ & 0x00004000) == 0x00004000)) {
        output.writeBool(54, allowSleep_);
      }
      if (((bitField0_ & 0x00008000) == 0x00008000)) {
        output.writeBool(55, awake_);
      }
      if (((bitField0_ & 0x00010000) == 0x00010000)) {
        output.writeBool(56, active_);
      }
      if (((bitField0_ & 0x00020000) == 0x00020000)) {
        output.writeBool(57, fixedRotation_);
      }
      for (int i = 0; i < fixtures_.size(); i++) {
        output.writeMessage(100, fixtures_.get(i));
      }
      getUnknownFields().writeTo(output);
    }
    
    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, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeEnumSize(2, type_.getNumber());
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(10, position_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(11, angle_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(12, linearVelocity_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(13, angularVelocity_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(14, force_);
      }
      if (((bitField0_ & 0x00000080) == 0x00000080)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(15, torque_);
      }
      if (((bitField0_ & 0x00000100) == 0x00000100)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(16, mass_);
      }
      if (((bitField0_ & 0x00000200) == 0x00000200)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(17, i_);
      }
      if (((bitField0_ & 0x00000400) == 0x00000400)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(50, linearDamping_);
      }
      if (((bitField0_ & 0x00000800) == 0x00000800)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(51, angularDamping_);
      }
      if (((bitField0_ & 0x00001000) == 0x00001000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeFloatSize(52, gravityScale_);
      }
      if (((bitField0_ & 0x00002000) == 0x00002000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(53, bullet_);
      }
      if (((bitField0_ & 0x00004000) == 0x00004000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(54, allowSleep_);
      }
      if (((bitField0_ & 0x00008000) == 0x00008000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(55, awake_);
      }
      if (((bitField0_ & 0x00010000) == 0x00010000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(56, active_);
      }
      if (((bitField0_ & 0x00020000) == 0x00020000)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(57, fixedRotation_);
      }
      for (int i = 0; i < fixtures_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(100, fixtures_.get(i));
      }
      size += getUnknownFields().getSerializedSize();
      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.box2d.proto.Box2D.PbBody parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.box2d.proto.Box2D.PbBody 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;
      }
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbBody parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.box2d.proto.Box2D.PbBody prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements org.box2d.proto.Box2D.PbBodyOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbBody_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbBody_fieldAccessorTable;
      }
      
      // Construct using org.box2d.proto.Box2D.PbBody.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getPositionFieldBuilder();
          getLinearVelocityFieldBuilder();
          getForceFieldBuilder();
          getFixturesFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        tag_ = 0L;
        bitField0_ = (bitField0_ & ~0x00000001);
        type_ = org.box2d.proto.Box2D.PbBodyType.STATIC;
        bitField0_ = (bitField0_ & ~0x00000002);
        if (positionBuilder_ == null) {
          position_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          positionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        angle_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000008);
        if (linearVelocityBuilder_ == null) {
          linearVelocity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          linearVelocityBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000010);
        angularVelocity_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000020);
        if (forceBuilder_ == null) {
          force_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          forceBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        torque_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000080);
        mass_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000100);
        i_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000200);
        linearDamping_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000400);
        angularDamping_ = 0F;
        bitField0_ = (bitField0_ & ~0x00000800);
        gravityScale_ = 0F;
        bitField0_ = (bitField0_ & ~0x00001000);
        bullet_ = false;
        bitField0_ = (bitField0_ & ~0x00002000);
        allowSleep_ = false;
        bitField0_ = (bitField0_ & ~0x00004000);
        awake_ = false;
        bitField0_ = (bitField0_ & ~0x00008000);
        active_ = false;
        bitField0_ = (bitField0_ & ~0x00010000);
        fixedRotation_ = false;
        bitField0_ = (bitField0_ & ~0x00020000);
        if (fixturesBuilder_ == null) {
          fixtures_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00040000);
        } else {
          fixturesBuilder_.clear();
        }
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.box2d.proto.Box2D.PbBody.getDescriptor();
      }
      
      public org.box2d.proto.Box2D.PbBody getDefaultInstanceForType() {
        return org.box2d.proto.Box2D.PbBody.getDefaultInstance();
      }
      
      public org.box2d.proto.Box2D.PbBody build() {
        org.box2d.proto.Box2D.PbBody result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private org.box2d.proto.Box2D.PbBody buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        org.box2d.proto.Box2D.PbBody result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public org.box2d.proto.Box2D.PbBody buildPartial() {
        org.box2d.proto.Box2D.PbBody result = new org.box2d.proto.Box2D.PbBody(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.tag_ = tag_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        result.type_ = type_;
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        if (positionBuilder_ == null) {
          result.position_ = position_;
        } else {
          result.position_ = positionBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
          to_bitField0_ |= 0x00000008;
        }
        result.angle_ = angle_;
        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
          to_bitField0_ |= 0x00000010;
        }
        if (linearVelocityBuilder_ == null) {
          result.linearVelocity_ = linearVelocity_;
        } else {
          result.linearVelocity_ = linearVelocityBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
          to_bitField0_ |= 0x00000020;
        }
        result.angularVelocity_ = angularVelocity_;
        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
          to_bitField0_ |= 0x00000040;
        }
        if (forceBuilder_ == null) {
          result.force_ = force_;
        } else {
          result.force_ = forceBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
          to_bitField0_ |= 0x00000080;
        }
        result.torque_ = torque_;
        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
          to_bitField0_ |= 0x00000100;
        }
        result.mass_ = mass_;
        if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
          to_bitField0_ |= 0x00000200;
        }
        result.i_ = i_;
        if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
          to_bitField0_ |= 0x00000400;
        }
        result.linearDamping_ = linearDamping_;
        if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
          to_bitField0_ |= 0x00000800;
        }
        result.angularDamping_ = angularDamping_;
        if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
          to_bitField0_ |= 0x00001000;
        }
        result.gravityScale_ = gravityScale_;
        if (((from_bitField0_ & 0x00002000) == 0x00002000)) {
          to_bitField0_ |= 0x00002000;
        }
        result.bullet_ = bullet_;
        if (((from_bitField0_ & 0x00004000) == 0x00004000)) {
          to_bitField0_ |= 0x00004000;
        }
        result.allowSleep_ = allowSleep_;
        if (((from_bitField0_ & 0x00008000) == 0x00008000)) {
          to_bitField0_ |= 0x00008000;
        }
        result.awake_ = awake_;
        if (((from_bitField0_ & 0x00010000) == 0x00010000)) {
          to_bitField0_ |= 0x00010000;
        }
        result.active_ = active_;
        if (((from_bitField0_ & 0x00020000) == 0x00020000)) {
          to_bitField0_ |= 0x00020000;
        }
        result.fixedRotation_ = fixedRotation_;
        if (fixturesBuilder_ == null) {
          if (((bitField0_ & 0x00040000) == 0x00040000)) {
            fixtures_ = java.util.Collections.unmodifiableList(fixtures_);
            bitField0_ = (bitField0_ & ~0x00040000);
          }
          result.fixtures_ = fixtures_;
        } else {
          result.fixtures_ = fixturesBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.box2d.proto.Box2D.PbBody) {
          return mergeFrom((org.box2d.proto.Box2D.PbBody)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.box2d.proto.Box2D.PbBody other) {
        if (other == org.box2d.proto.Box2D.PbBody.getDefaultInstance()) return this;
        if (other.hasTag()) {
          setTag(other.getTag());
        }
        if (other.hasType()) {
          setType(other.getType());
        }
        if (other.hasPosition()) {
          mergePosition(other.getPosition());
        }
        if (other.hasAngle()) {
          setAngle(other.getAngle());
        }
        if (other.hasLinearVelocity()) {
          mergeLinearVelocity(other.getLinearVelocity());
        }
        if (other.hasAngularVelocity()) {
          setAngularVelocity(other.getAngularVelocity());
        }
        if (other.hasForce()) {
          mergeForce(other.getForce());
        }
        if (other.hasTorque()) {
          setTorque(other.getTorque());
        }
        if (other.hasMass()) {
          setMass(other.getMass());
        }
        if (other.hasI()) {
          setI(other.getI());
        }
        if (other.hasLinearDamping()) {
          setLinearDamping(other.getLinearDamping());
        }
        if (other.hasAngularDamping()) {
          setAngularDamping(other.getAngularDamping());
        }
        if (other.hasGravityScale()) {
          setGravityScale(other.getGravityScale());
        }
        if (other.hasBullet()) {
          setBullet(other.getBullet());
        }
        if (other.hasAllowSleep()) {
          setAllowSleep(other.getAllowSleep());
        }
        if (other.hasAwake()) {
          setAwake(other.getAwake());
        }
        if (other.hasActive()) {
          setActive(other.getActive());
        }
        if (other.hasFixedRotation()) {
          setFixedRotation(other.getFixedRotation());
        }
        if (fixturesBuilder_ == null) {
          if (!other.fixtures_.isEmpty()) {
            if (fixtures_.isEmpty()) {
              fixtures_ = other.fixtures_;
              bitField0_ = (bitField0_ & ~0x00040000);
            } else {
              ensureFixturesIsMutable();
              fixtures_.addAll(other.fixtures_);
            }
            onChanged();
          }
        } else {
          if (!other.fixtures_.isEmpty()) {
            if (fixturesBuilder_.isEmpty()) {
              fixturesBuilder_.dispose();
              fixturesBuilder_ = null;
              fixtures_ = other.fixtures_;
              bitField0_ = (bitField0_ & ~0x00040000);
              fixturesBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getFixturesFieldBuilder() : null;
            } else {
              fixturesBuilder_.addAllMessages(other.fixtures_);
            }
          }
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (!hasType()) {
          
          return false;
        }
        if (hasPosition()) {
          if (!getPosition().isInitialized()) {
            
            return false;
          }
        }
        if (hasLinearVelocity()) {
          if (!getLinearVelocity().isInitialized()) {
            
            return false;
          }
        }
        if (hasForce()) {
          if (!getForce().isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getFixturesCount(); i++) {
          if (!getFixtures(i).isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              bitField0_ |= 0x00000001;
              tag_ = input.readInt64();
              break;
            }
            case 16: {
              int rawValue = input.readEnum();
              org.box2d.proto.Box2D.PbBodyType value = org.box2d.proto.Box2D.PbBodyType.valueOf(rawValue);
              if (value == null) {
                unknownFields.mergeVarintField(2, rawValue);
              } else {
                bitField0_ |= 0x00000002;
                type_ = value;
              }
              break;
            }
            case 82: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasPosition()) {
                subBuilder.mergeFrom(getPosition());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setPosition(subBuilder.buildPartial());
              break;
            }
            case 93: {
              bitField0_ |= 0x00000008;
              angle_ = input.readFloat();
              break;
            }
            case 98: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasLinearVelocity()) {
                subBuilder.mergeFrom(getLinearVelocity());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setLinearVelocity(subBuilder.buildPartial());
              break;
            }
            case 109: {
              bitField0_ |= 0x00000020;
              angularVelocity_ = input.readFloat();
              break;
            }
            case 114: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasForce()) {
                subBuilder.mergeFrom(getForce());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setForce(subBuilder.buildPartial());
              break;
            }
            case 125: {
              bitField0_ |= 0x00000080;
              torque_ = input.readFloat();
              break;
            }
            case 133: {
              bitField0_ |= 0x00000100;
              mass_ = input.readFloat();
              break;
            }
            case 141: {
              bitField0_ |= 0x00000200;
              i_ = input.readFloat();
              break;
            }
            case 405: {
              bitField0_ |= 0x00000400;
              linearDamping_ = input.readFloat();
              break;
            }
            case 413: {
              bitField0_ |= 0x00000800;
              angularDamping_ = input.readFloat();
              break;
            }
            case 421: {
              bitField0_ |= 0x00001000;
              gravityScale_ = input.readFloat();
              break;
            }
            case 424: {
              bitField0_ |= 0x00002000;
              bullet_ = input.readBool();
              break;
            }
            case 432: {
              bitField0_ |= 0x00004000;
              allowSleep_ = input.readBool();
              break;
            }
            case 440: {
              bitField0_ |= 0x00008000;
              awake_ = input.readBool();
              break;
            }
            case 448: {
              bitField0_ |= 0x00010000;
              active_ = input.readBool();
              break;
            }
            case 456: {
              bitField0_ |= 0x00020000;
              fixedRotation_ = input.readBool();
              break;
            }
            case 802: {
              org.box2d.proto.Box2D.PbFixture.Builder subBuilder = org.box2d.proto.Box2D.PbFixture.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addFixtures(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // optional int64 tag = 1;
      private long tag_ ;
      public boolean hasTag() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public long getTag() {
        return tag_;
      }
      public Builder setTag(long value) {
        bitField0_ |= 0x00000001;
        tag_ = value;
        onChanged();
        return this;
      }
      public Builder clearTag() {
        bitField0_ = (bitField0_ & ~0x00000001);
        tag_ = 0L;
        onChanged();
        return this;
      }
      
      // required .box2d.PbBodyType type = 2;
      private org.box2d.proto.Box2D.PbBodyType type_ = org.box2d.proto.Box2D.PbBodyType.STATIC;
      public boolean hasType() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public org.box2d.proto.Box2D.PbBodyType getType() {
        return type_;
      }
      public Builder setType(org.box2d.proto.Box2D.PbBodyType value) {
        if (value == null) {
          throw new NullPointerException();
        }
        bitField0_ |= 0x00000002;
        type_ = value;
        onChanged();
        return this;
      }
      public Builder clearType() {
        bitField0_ = (bitField0_ & ~0x00000002);
        type_ = org.box2d.proto.Box2D.PbBodyType.STATIC;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 position = 10;
      private org.box2d.proto.Box2D.PbVec2 position_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> positionBuilder_;
      public boolean hasPosition() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public org.box2d.proto.Box2D.PbVec2 getPosition() {
        if (positionBuilder_ == null) {
          return position_;
        } else {
          return positionBuilder_.getMessage();
        }
      }
      public Builder setPosition(org.box2d.proto.Box2D.PbVec2 value) {
        if (positionBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          position_ = value;
          onChanged();
        } else {
          positionBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder setPosition(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (positionBuilder_ == null) {
          position_ = builderForValue.build();
          onChanged();
        } else {
          positionBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder mergePosition(org.box2d.proto.Box2D.PbVec2 value) {
        if (positionBuilder_ == null) {
          if (((bitField0_ & 0x00000004) == 0x00000004) &&
              position_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            position_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(position_).mergeFrom(value).buildPartial();
          } else {
            position_ = value;
          }
          onChanged();
        } else {
          positionBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000004;
        return this;
      }
      public Builder clearPosition() {
        if (positionBuilder_ == null) {
          position_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          positionBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000004);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getPositionBuilder() {
        bitField0_ |= 0x00000004;
        onChanged();
        return getPositionFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getPositionOrBuilder() {
        if (positionBuilder_ != null) {
          return positionBuilder_.getMessageOrBuilder();
        } else {
          return position_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getPositionFieldBuilder() {
        if (positionBuilder_ == null) {
          positionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  position_,
                  getParentForChildren(),
                  isClean());
          position_ = null;
        }
        return positionBuilder_;
      }
      
      // optional float angle = 11;
      private float angle_ ;
      public boolean hasAngle() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public float getAngle() {
        return angle_;
      }
      public Builder setAngle(float value) {
        bitField0_ |= 0x00000008;
        angle_ = value;
        onChanged();
        return this;
      }
      public Builder clearAngle() {
        bitField0_ = (bitField0_ & ~0x00000008);
        angle_ = 0F;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 linear_velocity = 12;
      private org.box2d.proto.Box2D.PbVec2 linearVelocity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> linearVelocityBuilder_;
      public boolean hasLinearVelocity() {
        return ((bitField0_ & 0x00000010) == 0x00000010);
      }
      public org.box2d.proto.Box2D.PbVec2 getLinearVelocity() {
        if (linearVelocityBuilder_ == null) {
          return linearVelocity_;
        } else {
          return linearVelocityBuilder_.getMessage();
        }
      }
      public Builder setLinearVelocity(org.box2d.proto.Box2D.PbVec2 value) {
        if (linearVelocityBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          linearVelocity_ = value;
          onChanged();
        } else {
          linearVelocityBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000010;
        return this;
      }
      public Builder setLinearVelocity(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (linearVelocityBuilder_ == null) {
          linearVelocity_ = builderForValue.build();
          onChanged();
        } else {
          linearVelocityBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000010;
        return this;
      }
      public Builder mergeLinearVelocity(org.box2d.proto.Box2D.PbVec2 value) {
        if (linearVelocityBuilder_ == null) {
          if (((bitField0_ & 0x00000010) == 0x00000010) &&
              linearVelocity_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            linearVelocity_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(linearVelocity_).mergeFrom(value).buildPartial();
          } else {
            linearVelocity_ = value;
          }
          onChanged();
        } else {
          linearVelocityBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000010;
        return this;
      }
      public Builder clearLinearVelocity() {
        if (linearVelocityBuilder_ == null) {
          linearVelocity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          linearVelocityBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000010);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getLinearVelocityBuilder() {
        bitField0_ |= 0x00000010;
        onChanged();
        return getLinearVelocityFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getLinearVelocityOrBuilder() {
        if (linearVelocityBuilder_ != null) {
          return linearVelocityBuilder_.getMessageOrBuilder();
        } else {
          return linearVelocity_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getLinearVelocityFieldBuilder() {
        if (linearVelocityBuilder_ == null) {
          linearVelocityBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  linearVelocity_,
                  getParentForChildren(),
                  isClean());
          linearVelocity_ = null;
        }
        return linearVelocityBuilder_;
      }
      
      // optional float angular_velocity = 13;
      private float angularVelocity_ ;
      public boolean hasAngularVelocity() {
        return ((bitField0_ & 0x00000020) == 0x00000020);
      }
      public float getAngularVelocity() {
        return angularVelocity_;
      }
      public Builder setAngularVelocity(float value) {
        bitField0_ |= 0x00000020;
        angularVelocity_ = value;
        onChanged();
        return this;
      }
      public Builder clearAngularVelocity() {
        bitField0_ = (bitField0_ & ~0x00000020);
        angularVelocity_ = 0F;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 force = 14;
      private org.box2d.proto.Box2D.PbVec2 force_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> forceBuilder_;
      public boolean hasForce() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public org.box2d.proto.Box2D.PbVec2 getForce() {
        if (forceBuilder_ == null) {
          return force_;
        } else {
          return forceBuilder_.getMessage();
        }
      }
      public Builder setForce(org.box2d.proto.Box2D.PbVec2 value) {
        if (forceBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          force_ = value;
          onChanged();
        } else {
          forceBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder setForce(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (forceBuilder_ == null) {
          force_ = builderForValue.build();
          onChanged();
        } else {
          forceBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder mergeForce(org.box2d.proto.Box2D.PbVec2 value) {
        if (forceBuilder_ == null) {
          if (((bitField0_ & 0x00000040) == 0x00000040) &&
              force_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            force_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(force_).mergeFrom(value).buildPartial();
          } else {
            force_ = value;
          }
          onChanged();
        } else {
          forceBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000040;
        return this;
      }
      public Builder clearForce() {
        if (forceBuilder_ == null) {
          force_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          forceBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000040);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getForceBuilder() {
        bitField0_ |= 0x00000040;
        onChanged();
        return getForceFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getForceOrBuilder() {
        if (forceBuilder_ != null) {
          return forceBuilder_.getMessageOrBuilder();
        } else {
          return force_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getForceFieldBuilder() {
        if (forceBuilder_ == null) {
          forceBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  force_,
                  getParentForChildren(),
                  isClean());
          force_ = null;
        }
        return forceBuilder_;
      }
      
      // optional float torque = 15;
      private float torque_ ;
      public boolean hasTorque() {
        return ((bitField0_ & 0x00000080) == 0x00000080);
      }
      public float getTorque() {
        return torque_;
      }
      public Builder setTorque(float value) {
        bitField0_ |= 0x00000080;
        torque_ = value;
        onChanged();
        return this;
      }
      public Builder clearTorque() {
        bitField0_ = (bitField0_ & ~0x00000080);
        torque_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float mass = 16;
      private float mass_ ;
      public boolean hasMass() {
        return ((bitField0_ & 0x00000100) == 0x00000100);
      }
      public float getMass() {
        return mass_;
      }
      public Builder setMass(float value) {
        bitField0_ |= 0x00000100;
        mass_ = value;
        onChanged();
        return this;
      }
      public Builder clearMass() {
        bitField0_ = (bitField0_ & ~0x00000100);
        mass_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float I = 17;
      private float i_ ;
      public boolean hasI() {
        return ((bitField0_ & 0x00000200) == 0x00000200);
      }
      public float getI() {
        return i_;
      }
      public Builder setI(float value) {
        bitField0_ |= 0x00000200;
        i_ = value;
        onChanged();
        return this;
      }
      public Builder clearI() {
        bitField0_ = (bitField0_ & ~0x00000200);
        i_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float linear_damping = 50;
      private float linearDamping_ ;
      public boolean hasLinearDamping() {
        return ((bitField0_ & 0x00000400) == 0x00000400);
      }
      public float getLinearDamping() {
        return linearDamping_;
      }
      public Builder setLinearDamping(float value) {
        bitField0_ |= 0x00000400;
        linearDamping_ = value;
        onChanged();
        return this;
      }
      public Builder clearLinearDamping() {
        bitField0_ = (bitField0_ & ~0x00000400);
        linearDamping_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float angular_damping = 51;
      private float angularDamping_ ;
      public boolean hasAngularDamping() {
        return ((bitField0_ & 0x00000800) == 0x00000800);
      }
      public float getAngularDamping() {
        return angularDamping_;
      }
      public Builder setAngularDamping(float value) {
        bitField0_ |= 0x00000800;
        angularDamping_ = value;
        onChanged();
        return this;
      }
      public Builder clearAngularDamping() {
        bitField0_ = (bitField0_ & ~0x00000800);
        angularDamping_ = 0F;
        onChanged();
        return this;
      }
      
      // optional float gravity_scale = 52;
      private float gravityScale_ ;
      public boolean hasGravityScale() {
        return ((bitField0_ & 0x00001000) == 0x00001000);
      }
      public float getGravityScale() {
        return gravityScale_;
      }
      public Builder setGravityScale(float value) {
        bitField0_ |= 0x00001000;
        gravityScale_ = value;
        onChanged();
        return this;
      }
      public Builder clearGravityScale() {
        bitField0_ = (bitField0_ & ~0x00001000);
        gravityScale_ = 0F;
        onChanged();
        return this;
      }
      
      // optional bool bullet = 53;
      private boolean bullet_ ;
      public boolean hasBullet() {
        return ((bitField0_ & 0x00002000) == 0x00002000);
      }
      public boolean getBullet() {
        return bullet_;
      }
      public Builder setBullet(boolean value) {
        bitField0_ |= 0x00002000;
        bullet_ = value;
        onChanged();
        return this;
      }
      public Builder clearBullet() {
        bitField0_ = (bitField0_ & ~0x00002000);
        bullet_ = false;
        onChanged();
        return this;
      }
      
      // optional bool allow_sleep = 54;
      private boolean allowSleep_ ;
      public boolean hasAllowSleep() {
        return ((bitField0_ & 0x00004000) == 0x00004000);
      }
      public boolean getAllowSleep() {
        return allowSleep_;
      }
      public Builder setAllowSleep(boolean value) {
        bitField0_ |= 0x00004000;
        allowSleep_ = value;
        onChanged();
        return this;
      }
      public Builder clearAllowSleep() {
        bitField0_ = (bitField0_ & ~0x00004000);
        allowSleep_ = false;
        onChanged();
        return this;
      }
      
      // optional bool awake = 55;
      private boolean awake_ ;
      public boolean hasAwake() {
        return ((bitField0_ & 0x00008000) == 0x00008000);
      }
      public boolean getAwake() {
        return awake_;
      }
      public Builder setAwake(boolean value) {
        bitField0_ |= 0x00008000;
        awake_ = value;
        onChanged();
        return this;
      }
      public Builder clearAwake() {
        bitField0_ = (bitField0_ & ~0x00008000);
        awake_ = false;
        onChanged();
        return this;
      }
      
      // optional bool active = 56;
      private boolean active_ ;
      public boolean hasActive() {
        return ((bitField0_ & 0x00010000) == 0x00010000);
      }
      public boolean getActive() {
        return active_;
      }
      public Builder setActive(boolean value) {
        bitField0_ |= 0x00010000;
        active_ = value;
        onChanged();
        return this;
      }
      public Builder clearActive() {
        bitField0_ = (bitField0_ & ~0x00010000);
        active_ = false;
        onChanged();
        return this;
      }
      
      // optional bool fixed_rotation = 57;
      private boolean fixedRotation_ ;
      public boolean hasFixedRotation() {
        return ((bitField0_ & 0x00020000) == 0x00020000);
      }
      public boolean getFixedRotation() {
        return fixedRotation_;
      }
      public Builder setFixedRotation(boolean value) {
        bitField0_ |= 0x00020000;
        fixedRotation_ = value;
        onChanged();
        return this;
      }
      public Builder clearFixedRotation() {
        bitField0_ = (bitField0_ & ~0x00020000);
        fixedRotation_ = false;
        onChanged();
        return this;
      }
      
      // repeated .box2d.PbFixture fixtures = 100;
      private java.util.List<org.box2d.proto.Box2D.PbFixture> fixtures_ =
        java.util.Collections.emptyList();
      private void ensureFixturesIsMutable() {
        if (!((bitField0_ & 0x00040000) == 0x00040000)) {
          fixtures_ = new java.util.ArrayList<org.box2d.proto.Box2D.PbFixture>(fixtures_);
          bitField0_ |= 0x00040000;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbFixture, org.box2d.proto.Box2D.PbFixture.Builder, org.box2d.proto.Box2D.PbFixtureOrBuilder> fixturesBuilder_;
      
      public java.util.List<org.box2d.proto.Box2D.PbFixture> getFixturesList() {
        if (fixturesBuilder_ == null) {
          return java.util.Collections.unmodifiableList(fixtures_);
        } else {
          return fixturesBuilder_.getMessageList();
        }
      }
      public int getFixturesCount() {
        if (fixturesBuilder_ == null) {
          return fixtures_.size();
        } else {
          return fixturesBuilder_.getCount();
        }
      }
      public org.box2d.proto.Box2D.PbFixture getFixtures(int index) {
        if (fixturesBuilder_ == null) {
          return fixtures_.get(index);
        } else {
          return fixturesBuilder_.getMessage(index);
        }
      }
      public Builder setFixtures(
          int index, org.box2d.proto.Box2D.PbFixture value) {
        if (fixturesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFixturesIsMutable();
          fixtures_.set(index, value);
          onChanged();
        } else {
          fixturesBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setFixtures(
          int index, org.box2d.proto.Box2D.PbFixture.Builder builderForValue) {
        if (fixturesBuilder_ == null) {
          ensureFixturesIsMutable();
          fixtures_.set(index, builderForValue.build());
          onChanged();
        } else {
          fixturesBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addFixtures(org.box2d.proto.Box2D.PbFixture value) {
        if (fixturesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFixturesIsMutable();
          fixtures_.add(value);
          onChanged();
        } else {
          fixturesBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addFixtures(
          int index, org.box2d.proto.Box2D.PbFixture value) {
        if (fixturesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureFixturesIsMutable();
          fixtures_.add(index, value);
          onChanged();
        } else {
          fixturesBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addFixtures(
          org.box2d.proto.Box2D.PbFixture.Builder builderForValue) {
        if (fixturesBuilder_ == null) {
          ensureFixturesIsMutable();
          fixtures_.add(builderForValue.build());
          onChanged();
        } else {
          fixturesBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addFixtures(
          int index, org.box2d.proto.Box2D.PbFixture.Builder builderForValue) {
        if (fixturesBuilder_ == null) {
          ensureFixturesIsMutable();
          fixtures_.add(index, builderForValue.build());
          onChanged();
        } else {
          fixturesBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllFixtures(
          java.lang.Iterable<? extends org.box2d.proto.Box2D.PbFixture> values) {
        if (fixturesBuilder_ == null) {
          ensureFixturesIsMutable();
          super.addAll(values, fixtures_);
          onChanged();
        } else {
          fixturesBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearFixtures() {
        if (fixturesBuilder_ == null) {
          fixtures_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00040000);
          onChanged();
        } else {
          fixturesBuilder_.clear();
        }
        return this;
      }
      public Builder removeFixtures(int index) {
        if (fixturesBuilder_ == null) {
          ensureFixturesIsMutable();
          fixtures_.remove(index);
          onChanged();
        } else {
          fixturesBuilder_.remove(index);
        }
        return this;
      }
      public org.box2d.proto.Box2D.PbFixture.Builder getFixturesBuilder(
          int index) {
        return getFixturesFieldBuilder().getBuilder(index);
      }
      public org.box2d.proto.Box2D.PbFixtureOrBuilder getFixturesOrBuilder(
          int index) {
        if (fixturesBuilder_ == null) {
          return fixtures_.get(index);  } else {
          return fixturesBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends org.box2d.proto.Box2D.PbFixtureOrBuilder> 
           getFixturesOrBuilderList() {
        if (fixturesBuilder_ != null) {
          return fixturesBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(fixtures_);
        }
      }
      public org.box2d.proto.Box2D.PbFixture.Builder addFixturesBuilder() {
        return getFixturesFieldBuilder().addBuilder(
            org.box2d.proto.Box2D.PbFixture.getDefaultInstance());
      }
      public org.box2d.proto.Box2D.PbFixture.Builder addFixturesBuilder(
          int index) {
        return getFixturesFieldBuilder().addBuilder(
            index, org.box2d.proto.Box2D.PbFixture.getDefaultInstance());
      }
      public java.util.List<org.box2d.proto.Box2D.PbFixture.Builder> 
           getFixturesBuilderList() {
        return getFixturesFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbFixture, org.box2d.proto.Box2D.PbFixture.Builder, org.box2d.proto.Box2D.PbFixtureOrBuilder> 
          getFixturesFieldBuilder() {
        if (fixturesBuilder_ == null) {
          fixturesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              org.box2d.proto.Box2D.PbFixture, org.box2d.proto.Box2D.PbFixture.Builder, org.box2d.proto.Box2D.PbFixtureOrBuilder>(
                  fixtures_,
                  ((bitField0_ & 0x00040000) == 0x00040000),
                  getParentForChildren(),
                  isClean());
          fixtures_ = null;
        }
        return fixturesBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbBody)
    }
    
    static {
      defaultInstance = new PbBody(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbBody)
  }
  
  public interface PbWorldOrBuilder
      extends com.google.protobuf.MessageOrBuilder {
    
    // optional int64 tag = 1;
    boolean hasTag();
    long getTag();
    
    // optional .box2d.PbVec2 gravity = 2;
    boolean hasGravity();
    org.box2d.proto.Box2D.PbVec2 getGravity();
    org.box2d.proto.Box2D.PbVec2OrBuilder getGravityOrBuilder();
    
    // optional bool allow_sleep = 3;
    boolean hasAllowSleep();
    boolean getAllowSleep();
    
    // optional bool auto_clear_forces = 4;
    boolean hasAutoClearForces();
    boolean getAutoClearForces();
    
    // optional bool warm_starting = 5;
    boolean hasWarmStarting();
    boolean getWarmStarting();
    
    // optional bool continuous_physics = 6;
    boolean hasContinuousPhysics();
    boolean getContinuousPhysics();
    
    // optional bool sub_stepping = 7;
    boolean hasSubStepping();
    boolean getSubStepping();
    
    // repeated .box2d.PbBody bodies = 20;
    java.util.List<org.box2d.proto.Box2D.PbBody> 
        getBodiesList();
    org.box2d.proto.Box2D.PbBody getBodies(int index);
    int getBodiesCount();
    java.util.List<? extends org.box2d.proto.Box2D.PbBodyOrBuilder> 
        getBodiesOrBuilderList();
    org.box2d.proto.Box2D.PbBodyOrBuilder getBodiesOrBuilder(
        int index);
    
    // repeated .box2d.PbJoint joints = 21;
    java.util.List<org.box2d.proto.Box2D.PbJoint> 
        getJointsList();
    org.box2d.proto.Box2D.PbJoint getJoints(int index);
    int getJointsCount();
    java.util.List<? extends org.box2d.proto.Box2D.PbJointOrBuilder> 
        getJointsOrBuilderList();
    org.box2d.proto.Box2D.PbJointOrBuilder getJointsOrBuilder(
        int index);
  }
  public static final class PbWorld extends
      com.google.protobuf.GeneratedMessage
      implements PbWorldOrBuilder {
    // Use PbWorld.newBuilder() to construct.
    private PbWorld(Builder builder) {
      super(builder);
    }
    private PbWorld(boolean noInit) {}
    
    private static final PbWorld defaultInstance;
    public static PbWorld getDefaultInstance() {
      return defaultInstance;
    }
    
    public PbWorld getDefaultInstanceForType() {
      return defaultInstance;
    }
    
    public static final com.google.protobuf.Descriptors.Descriptor
        getDescriptor() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbWorld_descriptor;
    }
    
    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
        internalGetFieldAccessorTable() {
      return org.box2d.proto.Box2D.internal_static_box2d_PbWorld_fieldAccessorTable;
    }
    
    private int bitField0_;
    // optional int64 tag = 1;
    public static final int TAG_FIELD_NUMBER = 1;
    private long tag_;
    public boolean hasTag() {
      return ((bitField0_ & 0x00000001) == 0x00000001);
    }
    public long getTag() {
      return tag_;
    }
    
    // optional .box2d.PbVec2 gravity = 2;
    public static final int GRAVITY_FIELD_NUMBER = 2;
    private org.box2d.proto.Box2D.PbVec2 gravity_;
    public boolean hasGravity() {
      return ((bitField0_ & 0x00000002) == 0x00000002);
    }
    public org.box2d.proto.Box2D.PbVec2 getGravity() {
      return gravity_;
    }
    public org.box2d.proto.Box2D.PbVec2OrBuilder getGravityOrBuilder() {
      return gravity_;
    }
    
    // optional bool allow_sleep = 3;
    public static final int ALLOW_SLEEP_FIELD_NUMBER = 3;
    private boolean allowSleep_;
    public boolean hasAllowSleep() {
      return ((bitField0_ & 0x00000004) == 0x00000004);
    }
    public boolean getAllowSleep() {
      return allowSleep_;
    }
    
    // optional bool auto_clear_forces = 4;
    public static final int AUTO_CLEAR_FORCES_FIELD_NUMBER = 4;
    private boolean autoClearForces_;
    public boolean hasAutoClearForces() {
      return ((bitField0_ & 0x00000008) == 0x00000008);
    }
    public boolean getAutoClearForces() {
      return autoClearForces_;
    }
    
    // optional bool warm_starting = 5;
    public static final int WARM_STARTING_FIELD_NUMBER = 5;
    private boolean warmStarting_;
    public boolean hasWarmStarting() {
      return ((bitField0_ & 0x00000010) == 0x00000010);
    }
    public boolean getWarmStarting() {
      return warmStarting_;
    }
    
    // optional bool continuous_physics = 6;
    public static final int CONTINUOUS_PHYSICS_FIELD_NUMBER = 6;
    private boolean continuousPhysics_;
    public boolean hasContinuousPhysics() {
      return ((bitField0_ & 0x00000020) == 0x00000020);
    }
    public boolean getContinuousPhysics() {
      return continuousPhysics_;
    }
    
    // optional bool sub_stepping = 7;
    public static final int SUB_STEPPING_FIELD_NUMBER = 7;
    private boolean subStepping_;
    public boolean hasSubStepping() {
      return ((bitField0_ & 0x00000040) == 0x00000040);
    }
    public boolean getSubStepping() {
      return subStepping_;
    }
    
    // repeated .box2d.PbBody bodies = 20;
    public static final int BODIES_FIELD_NUMBER = 20;
    private java.util.List<org.box2d.proto.Box2D.PbBody> bodies_;
    public java.util.List<org.box2d.proto.Box2D.PbBody> getBodiesList() {
      return bodies_;
    }
    public java.util.List<? extends org.box2d.proto.Box2D.PbBodyOrBuilder> 
        getBodiesOrBuilderList() {
      return bodies_;
    }
    public int getBodiesCount() {
      return bodies_.size();
    }
    public org.box2d.proto.Box2D.PbBody getBodies(int index) {
      return bodies_.get(index);
    }
    public org.box2d.proto.Box2D.PbBodyOrBuilder getBodiesOrBuilder(
        int index) {
      return bodies_.get(index);
    }
    
    // repeated .box2d.PbJoint joints = 21;
    public static final int JOINTS_FIELD_NUMBER = 21;
    private java.util.List<org.box2d.proto.Box2D.PbJoint> joints_;
    public java.util.List<org.box2d.proto.Box2D.PbJoint> getJointsList() {
      return joints_;
    }
    public java.util.List<? extends org.box2d.proto.Box2D.PbJointOrBuilder> 
        getJointsOrBuilderList() {
      return joints_;
    }
    public int getJointsCount() {
      return joints_.size();
    }
    public org.box2d.proto.Box2D.PbJoint getJoints(int index) {
      return joints_.get(index);
    }
    public org.box2d.proto.Box2D.PbJointOrBuilder getJointsOrBuilder(
        int index) {
      return joints_.get(index);
    }
    
    private void initFields() {
      tag_ = 0L;
      gravity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      allowSleep_ = false;
      autoClearForces_ = false;
      warmStarting_ = false;
      continuousPhysics_ = false;
      subStepping_ = false;
      bodies_ = java.util.Collections.emptyList();
      joints_ = java.util.Collections.emptyList();
    }
    private byte memoizedIsInitialized = -1;
    public final boolean isInitialized() {
      byte isInitialized = memoizedIsInitialized;
      if (isInitialized != -1) return isInitialized == 1;
      
      if (hasGravity()) {
        if (!getGravity().isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getBodiesCount(); i++) {
        if (!getBodies(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      for (int i = 0; i < getJointsCount(); i++) {
        if (!getJoints(i).isInitialized()) {
          memoizedIsInitialized = 0;
          return false;
        }
      }
      memoizedIsInitialized = 1;
      return true;
    }
    
    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      getSerializedSize();
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        output.writeInt64(1, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        output.writeMessage(2, gravity_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeBool(3, allowSleep_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeBool(4, autoClearForces_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeBool(5, warmStarting_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        output.writeBool(6, continuousPhysics_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        output.writeBool(7, subStepping_);
      }
      for (int i = 0; i < bodies_.size(); i++) {
        output.writeMessage(20, bodies_.get(i));
      }
      for (int i = 0; i < joints_.size(); i++) {
        output.writeMessage(21, joints_.get(i));
      }
      getUnknownFields().writeTo(output);
    }
    
    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, tag_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(2, gravity_);
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(3, allowSleep_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(4, autoClearForces_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(5, warmStarting_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(6, continuousPhysics_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        size += com.google.protobuf.CodedOutputStream
          .computeBoolSize(7, subStepping_);
      }
      for (int i = 0; i < bodies_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(20, bodies_.get(i));
      }
      for (int i = 0; i < joints_.size(); i++) {
        size += com.google.protobuf.CodedOutputStream
          .computeMessageSize(21, joints_.get(i));
      }
      size += getUnknownFields().getSerializedSize();
      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.box2d.proto.Box2D.PbWorld parseFrom(
        com.google.protobuf.ByteString data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(
        com.google.protobuf.ByteString data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(byte[] data)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(
        byte[] data,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws com.google.protobuf.InvalidProtocolBufferException {
      return newBuilder().mergeFrom(data, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(java.io.InputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(
        java.io.InputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseDelimitedFrom(java.io.InputStream input)
        throws java.io.IOException {
      Builder builder = newBuilder();
      if (builder.mergeDelimitedFrom(input)) {
        return builder.buildParsed();
      } else {
        return null;
      }
    }
    public static org.box2d.proto.Box2D.PbWorld 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;
      }
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(
        com.google.protobuf.CodedInputStream input)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input).buildParsed();
    }
    public static org.box2d.proto.Box2D.PbWorld parseFrom(
        com.google.protobuf.CodedInputStream input,
        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
        throws java.io.IOException {
      return newBuilder().mergeFrom(input, extensionRegistry)
               .buildParsed();
    }
    
    public static Builder newBuilder() { return Builder.create(); }
    public Builder newBuilderForType() { return newBuilder(); }
    public static Builder newBuilder(org.box2d.proto.Box2D.PbWorld prototype) {
      return newBuilder().mergeFrom(prototype);
    }
    public Builder toBuilder() { return newBuilder(this); }
    
    @java.lang.Override
    protected Builder newBuilderForType(
        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
      Builder builder = new Builder(parent);
      return builder;
    }
    public static final class Builder extends
        com.google.protobuf.GeneratedMessage.Builder<Builder>
       implements org.box2d.proto.Box2D.PbWorldOrBuilder {
      public static final com.google.protobuf.Descriptors.Descriptor
          getDescriptor() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbWorld_descriptor;
      }
      
      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
          internalGetFieldAccessorTable() {
        return org.box2d.proto.Box2D.internal_static_box2d_PbWorld_fieldAccessorTable;
      }
      
      // Construct using org.box2d.proto.Box2D.PbWorld.newBuilder()
      private Builder() {
        maybeForceBuilderInitialization();
      }
      
      private Builder(BuilderParent parent) {
        super(parent);
        maybeForceBuilderInitialization();
      }
      private void maybeForceBuilderInitialization() {
        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
          getGravityFieldBuilder();
          getBodiesFieldBuilder();
          getJointsFieldBuilder();
        }
      }
      private static Builder create() {
        return new Builder();
      }
      
      public Builder clear() {
        super.clear();
        tag_ = 0L;
        bitField0_ = (bitField0_ & ~0x00000001);
        if (gravityBuilder_ == null) {
          gravity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
        } else {
          gravityBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        allowSleep_ = false;
        bitField0_ = (bitField0_ & ~0x00000004);
        autoClearForces_ = false;
        bitField0_ = (bitField0_ & ~0x00000008);
        warmStarting_ = false;
        bitField0_ = (bitField0_ & ~0x00000010);
        continuousPhysics_ = false;
        bitField0_ = (bitField0_ & ~0x00000020);
        subStepping_ = false;
        bitField0_ = (bitField0_ & ~0x00000040);
        if (bodiesBuilder_ == null) {
          bodies_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000080);
        } else {
          bodiesBuilder_.clear();
        }
        if (jointsBuilder_ == null) {
          joints_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000100);
        } else {
          jointsBuilder_.clear();
        }
        return this;
      }
      
      public Builder clone() {
        return create().mergeFrom(buildPartial());
      }
      
      public com.google.protobuf.Descriptors.Descriptor
          getDescriptorForType() {
        return org.box2d.proto.Box2D.PbWorld.getDescriptor();
      }
      
      public org.box2d.proto.Box2D.PbWorld getDefaultInstanceForType() {
        return org.box2d.proto.Box2D.PbWorld.getDefaultInstance();
      }
      
      public org.box2d.proto.Box2D.PbWorld build() {
        org.box2d.proto.Box2D.PbWorld result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(result);
        }
        return result;
      }
      
      private org.box2d.proto.Box2D.PbWorld buildParsed()
          throws com.google.protobuf.InvalidProtocolBufferException {
        org.box2d.proto.Box2D.PbWorld result = buildPartial();
        if (!result.isInitialized()) {
          throw newUninitializedMessageException(
            result).asInvalidProtocolBufferException();
        }
        return result;
      }
      
      public org.box2d.proto.Box2D.PbWorld buildPartial() {
        org.box2d.proto.Box2D.PbWorld result = new org.box2d.proto.Box2D.PbWorld(this);
        int from_bitField0_ = bitField0_;
        int to_bitField0_ = 0;
        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
          to_bitField0_ |= 0x00000001;
        }
        result.tag_ = tag_;
        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
          to_bitField0_ |= 0x00000002;
        }
        if (gravityBuilder_ == null) {
          result.gravity_ = gravity_;
        } else {
          result.gravity_ = gravityBuilder_.build();
        }
        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
          to_bitField0_ |= 0x00000004;
        }
        result.allowSleep_ = allowSleep_;
        if (((from_bitField0_ & 0x00000008) == 0x00000008)) {
          to_bitField0_ |= 0x00000008;
        }
        result.autoClearForces_ = autoClearForces_;
        if (((from_bitField0_ & 0x00000010) == 0x00000010)) {
          to_bitField0_ |= 0x00000010;
        }
        result.warmStarting_ = warmStarting_;
        if (((from_bitField0_ & 0x00000020) == 0x00000020)) {
          to_bitField0_ |= 0x00000020;
        }
        result.continuousPhysics_ = continuousPhysics_;
        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
          to_bitField0_ |= 0x00000040;
        }
        result.subStepping_ = subStepping_;
        if (bodiesBuilder_ == null) {
          if (((bitField0_ & 0x00000080) == 0x00000080)) {
            bodies_ = java.util.Collections.unmodifiableList(bodies_);
            bitField0_ = (bitField0_ & ~0x00000080);
          }
          result.bodies_ = bodies_;
        } else {
          result.bodies_ = bodiesBuilder_.build();
        }
        if (jointsBuilder_ == null) {
          if (((bitField0_ & 0x00000100) == 0x00000100)) {
            joints_ = java.util.Collections.unmodifiableList(joints_);
            bitField0_ = (bitField0_ & ~0x00000100);
          }
          result.joints_ = joints_;
        } else {
          result.joints_ = jointsBuilder_.build();
        }
        result.bitField0_ = to_bitField0_;
        onBuilt();
        return result;
      }
      
      public Builder mergeFrom(com.google.protobuf.Message other) {
        if (other instanceof org.box2d.proto.Box2D.PbWorld) {
          return mergeFrom((org.box2d.proto.Box2D.PbWorld)other);
        } else {
          super.mergeFrom(other);
          return this;
        }
      }
      
      public Builder mergeFrom(org.box2d.proto.Box2D.PbWorld other) {
        if (other == org.box2d.proto.Box2D.PbWorld.getDefaultInstance()) return this;
        if (other.hasTag()) {
          setTag(other.getTag());
        }
        if (other.hasGravity()) {
          mergeGravity(other.getGravity());
        }
        if (other.hasAllowSleep()) {
          setAllowSleep(other.getAllowSleep());
        }
        if (other.hasAutoClearForces()) {
          setAutoClearForces(other.getAutoClearForces());
        }
        if (other.hasWarmStarting()) {
          setWarmStarting(other.getWarmStarting());
        }
        if (other.hasContinuousPhysics()) {
          setContinuousPhysics(other.getContinuousPhysics());
        }
        if (other.hasSubStepping()) {
          setSubStepping(other.getSubStepping());
        }
        if (bodiesBuilder_ == null) {
          if (!other.bodies_.isEmpty()) {
            if (bodies_.isEmpty()) {
              bodies_ = other.bodies_;
              bitField0_ = (bitField0_ & ~0x00000080);
            } else {
              ensureBodiesIsMutable();
              bodies_.addAll(other.bodies_);
            }
            onChanged();
          }
        } else {
          if (!other.bodies_.isEmpty()) {
            if (bodiesBuilder_.isEmpty()) {
              bodiesBuilder_.dispose();
              bodiesBuilder_ = null;
              bodies_ = other.bodies_;
              bitField0_ = (bitField0_ & ~0x00000080);
              bodiesBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getBodiesFieldBuilder() : null;
            } else {
              bodiesBuilder_.addAllMessages(other.bodies_);
            }
          }
        }
        if (jointsBuilder_ == null) {
          if (!other.joints_.isEmpty()) {
            if (joints_.isEmpty()) {
              joints_ = other.joints_;
              bitField0_ = (bitField0_ & ~0x00000100);
            } else {
              ensureJointsIsMutable();
              joints_.addAll(other.joints_);
            }
            onChanged();
          }
        } else {
          if (!other.joints_.isEmpty()) {
            if (jointsBuilder_.isEmpty()) {
              jointsBuilder_.dispose();
              jointsBuilder_ = null;
              joints_ = other.joints_;
              bitField0_ = (bitField0_ & ~0x00000100);
              jointsBuilder_ = 
                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                   getJointsFieldBuilder() : null;
            } else {
              jointsBuilder_.addAllMessages(other.joints_);
            }
          }
        }
        this.mergeUnknownFields(other.getUnknownFields());
        return this;
      }
      
      public final boolean isInitialized() {
        if (hasGravity()) {
          if (!getGravity().isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getBodiesCount(); i++) {
          if (!getBodies(i).isInitialized()) {
            
            return false;
          }
        }
        for (int i = 0; i < getJointsCount(); i++) {
          if (!getJoints(i).isInitialized()) {
            
            return false;
          }
        }
        return true;
      }
      
      public Builder mergeFrom(
          com.google.protobuf.CodedInputStream input,
          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
          throws java.io.IOException {
        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
          com.google.protobuf.UnknownFieldSet.newBuilder(
            this.getUnknownFields());
        while (true) {
          int tag = input.readTag();
          switch (tag) {
            case 0:
              this.setUnknownFields(unknownFields.build());
              onChanged();
              return this;
            default: {
              if (!parseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.setUnknownFields(unknownFields.build());
                onChanged();
                return this;
              }
              break;
            }
            case 8: {
              bitField0_ |= 0x00000001;
              tag_ = input.readInt64();
              break;
            }
            case 18: {
              org.box2d.proto.Box2D.PbVec2.Builder subBuilder = org.box2d.proto.Box2D.PbVec2.newBuilder();
              if (hasGravity()) {
                subBuilder.mergeFrom(getGravity());
              }
              input.readMessage(subBuilder, extensionRegistry);
              setGravity(subBuilder.buildPartial());
              break;
            }
            case 24: {
              bitField0_ |= 0x00000004;
              allowSleep_ = input.readBool();
              break;
            }
            case 32: {
              bitField0_ |= 0x00000008;
              autoClearForces_ = input.readBool();
              break;
            }
            case 40: {
              bitField0_ |= 0x00000010;
              warmStarting_ = input.readBool();
              break;
            }
            case 48: {
              bitField0_ |= 0x00000020;
              continuousPhysics_ = input.readBool();
              break;
            }
            case 56: {
              bitField0_ |= 0x00000040;
              subStepping_ = input.readBool();
              break;
            }
            case 162: {
              org.box2d.proto.Box2D.PbBody.Builder subBuilder = org.box2d.proto.Box2D.PbBody.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addBodies(subBuilder.buildPartial());
              break;
            }
            case 170: {
              org.box2d.proto.Box2D.PbJoint.Builder subBuilder = org.box2d.proto.Box2D.PbJoint.newBuilder();
              input.readMessage(subBuilder, extensionRegistry);
              addJoints(subBuilder.buildPartial());
              break;
            }
          }
        }
      }
      
      private int bitField0_;
      
      // optional int64 tag = 1;
      private long tag_ ;
      public boolean hasTag() {
        return ((bitField0_ & 0x00000001) == 0x00000001);
      }
      public long getTag() {
        return tag_;
      }
      public Builder setTag(long value) {
        bitField0_ |= 0x00000001;
        tag_ = value;
        onChanged();
        return this;
      }
      public Builder clearTag() {
        bitField0_ = (bitField0_ & ~0x00000001);
        tag_ = 0L;
        onChanged();
        return this;
      }
      
      // optional .box2d.PbVec2 gravity = 2;
      private org.box2d.proto.Box2D.PbVec2 gravity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> gravityBuilder_;
      public boolean hasGravity() {
        return ((bitField0_ & 0x00000002) == 0x00000002);
      }
      public org.box2d.proto.Box2D.PbVec2 getGravity() {
        if (gravityBuilder_ == null) {
          return gravity_;
        } else {
          return gravityBuilder_.getMessage();
        }
      }
      public Builder setGravity(org.box2d.proto.Box2D.PbVec2 value) {
        if (gravityBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          gravity_ = value;
          onChanged();
        } else {
          gravityBuilder_.setMessage(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder setGravity(
          org.box2d.proto.Box2D.PbVec2.Builder builderForValue) {
        if (gravityBuilder_ == null) {
          gravity_ = builderForValue.build();
          onChanged();
        } else {
          gravityBuilder_.setMessage(builderForValue.build());
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder mergeGravity(org.box2d.proto.Box2D.PbVec2 value) {
        if (gravityBuilder_ == null) {
          if (((bitField0_ & 0x00000002) == 0x00000002) &&
              gravity_ != org.box2d.proto.Box2D.PbVec2.getDefaultInstance()) {
            gravity_ =
              org.box2d.proto.Box2D.PbVec2.newBuilder(gravity_).mergeFrom(value).buildPartial();
          } else {
            gravity_ = value;
          }
          onChanged();
        } else {
          gravityBuilder_.mergeFrom(value);
        }
        bitField0_ |= 0x00000002;
        return this;
      }
      public Builder clearGravity() {
        if (gravityBuilder_ == null) {
          gravity_ = org.box2d.proto.Box2D.PbVec2.getDefaultInstance();
          onChanged();
        } else {
          gravityBuilder_.clear();
        }
        bitField0_ = (bitField0_ & ~0x00000002);
        return this;
      }
      public org.box2d.proto.Box2D.PbVec2.Builder getGravityBuilder() {
        bitField0_ |= 0x00000002;
        onChanged();
        return getGravityFieldBuilder().getBuilder();
      }
      public org.box2d.proto.Box2D.PbVec2OrBuilder getGravityOrBuilder() {
        if (gravityBuilder_ != null) {
          return gravityBuilder_.getMessageOrBuilder();
        } else {
          return gravity_;
        }
      }
      private com.google.protobuf.SingleFieldBuilder<
          org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder> 
          getGravityFieldBuilder() {
        if (gravityBuilder_ == null) {
          gravityBuilder_ = new com.google.protobuf.SingleFieldBuilder<
              org.box2d.proto.Box2D.PbVec2, org.box2d.proto.Box2D.PbVec2.Builder, org.box2d.proto.Box2D.PbVec2OrBuilder>(
                  gravity_,
                  getParentForChildren(),
                  isClean());
          gravity_ = null;
        }
        return gravityBuilder_;
      }
      
      // optional bool allow_sleep = 3;
      private boolean allowSleep_ ;
      public boolean hasAllowSleep() {
        return ((bitField0_ & 0x00000004) == 0x00000004);
      }
      public boolean getAllowSleep() {
        return allowSleep_;
      }
      public Builder setAllowSleep(boolean value) {
        bitField0_ |= 0x00000004;
        allowSleep_ = value;
        onChanged();
        return this;
      }
      public Builder clearAllowSleep() {
        bitField0_ = (bitField0_ & ~0x00000004);
        allowSleep_ = false;
        onChanged();
        return this;
      }
      
      // optional bool auto_clear_forces = 4;
      private boolean autoClearForces_ ;
      public boolean hasAutoClearForces() {
        return ((bitField0_ & 0x00000008) == 0x00000008);
      }
      public boolean getAutoClearForces() {
        return autoClearForces_;
      }
      public Builder setAutoClearForces(boolean value) {
        bitField0_ |= 0x00000008;
        autoClearForces_ = value;
        onChanged();
        return this;
      }
      public Builder clearAutoClearForces() {
        bitField0_ = (bitField0_ & ~0x00000008);
        autoClearForces_ = false;
        onChanged();
        return this;
      }
      
      // optional bool warm_starting = 5;
      private boolean warmStarting_ ;
      public boolean hasWarmStarting() {
        return ((bitField0_ & 0x00000010) == 0x00000010);
      }
      public boolean getWarmStarting() {
        return warmStarting_;
      }
      public Builder setWarmStarting(boolean value) {
        bitField0_ |= 0x00000010;
        warmStarting_ = value;
        onChanged();
        return this;
      }
      public Builder clearWarmStarting() {
        bitField0_ = (bitField0_ & ~0x00000010);
        warmStarting_ = false;
        onChanged();
        return this;
      }
      
      // optional bool continuous_physics = 6;
      private boolean continuousPhysics_ ;
      public boolean hasContinuousPhysics() {
        return ((bitField0_ & 0x00000020) == 0x00000020);
      }
      public boolean getContinuousPhysics() {
        return continuousPhysics_;
      }
      public Builder setContinuousPhysics(boolean value) {
        bitField0_ |= 0x00000020;
        continuousPhysics_ = value;
        onChanged();
        return this;
      }
      public Builder clearContinuousPhysics() {
        bitField0_ = (bitField0_ & ~0x00000020);
        continuousPhysics_ = false;
        onChanged();
        return this;
      }
      
      // optional bool sub_stepping = 7;
      private boolean subStepping_ ;
      public boolean hasSubStepping() {
        return ((bitField0_ & 0x00000040) == 0x00000040);
      }
      public boolean getSubStepping() {
        return subStepping_;
      }
      public Builder setSubStepping(boolean value) {
        bitField0_ |= 0x00000040;
        subStepping_ = value;
        onChanged();
        return this;
      }
      public Builder clearSubStepping() {
        bitField0_ = (bitField0_ & ~0x00000040);
        subStepping_ = false;
        onChanged();
        return this;
      }
      
      // repeated .box2d.PbBody bodies = 20;
      private java.util.List<org.box2d.proto.Box2D.PbBody> bodies_ =
        java.util.Collections.emptyList();
      private void ensureBodiesIsMutable() {
        if (!((bitField0_ & 0x00000080) == 0x00000080)) {
          bodies_ = new java.util.ArrayList<org.box2d.proto.Box2D.PbBody>(bodies_);
          bitField0_ |= 0x00000080;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbBody, org.box2d.proto.Box2D.PbBody.Builder, org.box2d.proto.Box2D.PbBodyOrBuilder> bodiesBuilder_;
      
      public java.util.List<org.box2d.proto.Box2D.PbBody> getBodiesList() {
        if (bodiesBuilder_ == null) {
          return java.util.Collections.unmodifiableList(bodies_);
        } else {
          return bodiesBuilder_.getMessageList();
        }
      }
      public int getBodiesCount() {
        if (bodiesBuilder_ == null) {
          return bodies_.size();
        } else {
          return bodiesBuilder_.getCount();
        }
      }
      public org.box2d.proto.Box2D.PbBody getBodies(int index) {
        if (bodiesBuilder_ == null) {
          return bodies_.get(index);
        } else {
          return bodiesBuilder_.getMessage(index);
        }
      }
      public Builder setBodies(
          int index, org.box2d.proto.Box2D.PbBody value) {
        if (bodiesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureBodiesIsMutable();
          bodies_.set(index, value);
          onChanged();
        } else {
          bodiesBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setBodies(
          int index, org.box2d.proto.Box2D.PbBody.Builder builderForValue) {
        if (bodiesBuilder_ == null) {
          ensureBodiesIsMutable();
          bodies_.set(index, builderForValue.build());
          onChanged();
        } else {
          bodiesBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addBodies(org.box2d.proto.Box2D.PbBody value) {
        if (bodiesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureBodiesIsMutable();
          bodies_.add(value);
          onChanged();
        } else {
          bodiesBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addBodies(
          int index, org.box2d.proto.Box2D.PbBody value) {
        if (bodiesBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureBodiesIsMutable();
          bodies_.add(index, value);
          onChanged();
        } else {
          bodiesBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addBodies(
          org.box2d.proto.Box2D.PbBody.Builder builderForValue) {
        if (bodiesBuilder_ == null) {
          ensureBodiesIsMutable();
          bodies_.add(builderForValue.build());
          onChanged();
        } else {
          bodiesBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addBodies(
          int index, org.box2d.proto.Box2D.PbBody.Builder builderForValue) {
        if (bodiesBuilder_ == null) {
          ensureBodiesIsMutable();
          bodies_.add(index, builderForValue.build());
          onChanged();
        } else {
          bodiesBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllBodies(
          java.lang.Iterable<? extends org.box2d.proto.Box2D.PbBody> values) {
        if (bodiesBuilder_ == null) {
          ensureBodiesIsMutable();
          super.addAll(values, bodies_);
          onChanged();
        } else {
          bodiesBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearBodies() {
        if (bodiesBuilder_ == null) {
          bodies_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000080);
          onChanged();
        } else {
          bodiesBuilder_.clear();
        }
        return this;
      }
      public Builder removeBodies(int index) {
        if (bodiesBuilder_ == null) {
          ensureBodiesIsMutable();
          bodies_.remove(index);
          onChanged();
        } else {
          bodiesBuilder_.remove(index);
        }
        return this;
      }
      public org.box2d.proto.Box2D.PbBody.Builder getBodiesBuilder(
          int index) {
        return getBodiesFieldBuilder().getBuilder(index);
      }
      public org.box2d.proto.Box2D.PbBodyOrBuilder getBodiesOrBuilder(
          int index) {
        if (bodiesBuilder_ == null) {
          return bodies_.get(index);  } else {
          return bodiesBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends org.box2d.proto.Box2D.PbBodyOrBuilder> 
           getBodiesOrBuilderList() {
        if (bodiesBuilder_ != null) {
          return bodiesBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(bodies_);
        }
      }
      public org.box2d.proto.Box2D.PbBody.Builder addBodiesBuilder() {
        return getBodiesFieldBuilder().addBuilder(
            org.box2d.proto.Box2D.PbBody.getDefaultInstance());
      }
      public org.box2d.proto.Box2D.PbBody.Builder addBodiesBuilder(
          int index) {
        return getBodiesFieldBuilder().addBuilder(
            index, org.box2d.proto.Box2D.PbBody.getDefaultInstance());
      }
      public java.util.List<org.box2d.proto.Box2D.PbBody.Builder> 
           getBodiesBuilderList() {
        return getBodiesFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbBody, org.box2d.proto.Box2D.PbBody.Builder, org.box2d.proto.Box2D.PbBodyOrBuilder> 
          getBodiesFieldBuilder() {
        if (bodiesBuilder_ == null) {
          bodiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              org.box2d.proto.Box2D.PbBody, org.box2d.proto.Box2D.PbBody.Builder, org.box2d.proto.Box2D.PbBodyOrBuilder>(
                  bodies_,
                  ((bitField0_ & 0x00000080) == 0x00000080),
                  getParentForChildren(),
                  isClean());
          bodies_ = null;
        }
        return bodiesBuilder_;
      }
      
      // repeated .box2d.PbJoint joints = 21;
      private java.util.List<org.box2d.proto.Box2D.PbJoint> joints_ =
        java.util.Collections.emptyList();
      private void ensureJointsIsMutable() {
        if (!((bitField0_ & 0x00000100) == 0x00000100)) {
          joints_ = new java.util.ArrayList<org.box2d.proto.Box2D.PbJoint>(joints_);
          bitField0_ |= 0x00000100;
         }
      }
      
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbJoint, org.box2d.proto.Box2D.PbJoint.Builder, org.box2d.proto.Box2D.PbJointOrBuilder> jointsBuilder_;
      
      public java.util.List<org.box2d.proto.Box2D.PbJoint> getJointsList() {
        if (jointsBuilder_ == null) {
          return java.util.Collections.unmodifiableList(joints_);
        } else {
          return jointsBuilder_.getMessageList();
        }
      }
      public int getJointsCount() {
        if (jointsBuilder_ == null) {
          return joints_.size();
        } else {
          return jointsBuilder_.getCount();
        }
      }
      public org.box2d.proto.Box2D.PbJoint getJoints(int index) {
        if (jointsBuilder_ == null) {
          return joints_.get(index);
        } else {
          return jointsBuilder_.getMessage(index);
        }
      }
      public Builder setJoints(
          int index, org.box2d.proto.Box2D.PbJoint value) {
        if (jointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureJointsIsMutable();
          joints_.set(index, value);
          onChanged();
        } else {
          jointsBuilder_.setMessage(index, value);
        }
        return this;
      }
      public Builder setJoints(
          int index, org.box2d.proto.Box2D.PbJoint.Builder builderForValue) {
        if (jointsBuilder_ == null) {
          ensureJointsIsMutable();
          joints_.set(index, builderForValue.build());
          onChanged();
        } else {
          jointsBuilder_.setMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addJoints(org.box2d.proto.Box2D.PbJoint value) {
        if (jointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureJointsIsMutable();
          joints_.add(value);
          onChanged();
        } else {
          jointsBuilder_.addMessage(value);
        }
        return this;
      }
      public Builder addJoints(
          int index, org.box2d.proto.Box2D.PbJoint value) {
        if (jointsBuilder_ == null) {
          if (value == null) {
            throw new NullPointerException();
          }
          ensureJointsIsMutable();
          joints_.add(index, value);
          onChanged();
        } else {
          jointsBuilder_.addMessage(index, value);
        }
        return this;
      }
      public Builder addJoints(
          org.box2d.proto.Box2D.PbJoint.Builder builderForValue) {
        if (jointsBuilder_ == null) {
          ensureJointsIsMutable();
          joints_.add(builderForValue.build());
          onChanged();
        } else {
          jointsBuilder_.addMessage(builderForValue.build());
        }
        return this;
      }
      public Builder addJoints(
          int index, org.box2d.proto.Box2D.PbJoint.Builder builderForValue) {
        if (jointsBuilder_ == null) {
          ensureJointsIsMutable();
          joints_.add(index, builderForValue.build());
          onChanged();
        } else {
          jointsBuilder_.addMessage(index, builderForValue.build());
        }
        return this;
      }
      public Builder addAllJoints(
          java.lang.Iterable<? extends org.box2d.proto.Box2D.PbJoint> values) {
        if (jointsBuilder_ == null) {
          ensureJointsIsMutable();
          super.addAll(values, joints_);
          onChanged();
        } else {
          jointsBuilder_.addAllMessages(values);
        }
        return this;
      }
      public Builder clearJoints() {
        if (jointsBuilder_ == null) {
          joints_ = java.util.Collections.emptyList();
          bitField0_ = (bitField0_ & ~0x00000100);
          onChanged();
        } else {
          jointsBuilder_.clear();
        }
        return this;
      }
      public Builder removeJoints(int index) {
        if (jointsBuilder_ == null) {
          ensureJointsIsMutable();
          joints_.remove(index);
          onChanged();
        } else {
          jointsBuilder_.remove(index);
        }
        return this;
      }
      public org.box2d.proto.Box2D.PbJoint.Builder getJointsBuilder(
          int index) {
        return getJointsFieldBuilder().getBuilder(index);
      }
      public org.box2d.proto.Box2D.PbJointOrBuilder getJointsOrBuilder(
          int index) {
        if (jointsBuilder_ == null) {
          return joints_.get(index);  } else {
          return jointsBuilder_.getMessageOrBuilder(index);
        }
      }
      public java.util.List<? extends org.box2d.proto.Box2D.PbJointOrBuilder> 
           getJointsOrBuilderList() {
        if (jointsBuilder_ != null) {
          return jointsBuilder_.getMessageOrBuilderList();
        } else {
          return java.util.Collections.unmodifiableList(joints_);
        }
      }
      public org.box2d.proto.Box2D.PbJoint.Builder addJointsBuilder() {
        return getJointsFieldBuilder().addBuilder(
            org.box2d.proto.Box2D.PbJoint.getDefaultInstance());
      }
      public org.box2d.proto.Box2D.PbJoint.Builder addJointsBuilder(
          int index) {
        return getJointsFieldBuilder().addBuilder(
            index, org.box2d.proto.Box2D.PbJoint.getDefaultInstance());
      }
      public java.util.List<org.box2d.proto.Box2D.PbJoint.Builder> 
           getJointsBuilderList() {
        return getJointsFieldBuilder().getBuilderList();
      }
      private com.google.protobuf.RepeatedFieldBuilder<
          org.box2d.proto.Box2D.PbJoint, org.box2d.proto.Box2D.PbJoint.Builder, org.box2d.proto.Box2D.PbJointOrBuilder> 
          getJointsFieldBuilder() {
        if (jointsBuilder_ == null) {
          jointsBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
              org.box2d.proto.Box2D.PbJoint, org.box2d.proto.Box2D.PbJoint.Builder, org.box2d.proto.Box2D.PbJointOrBuilder>(
                  joints_,
                  ((bitField0_ & 0x00000100) == 0x00000100),
                  getParentForChildren(),
                  isClean());
          joints_ = null;
        }
        return jointsBuilder_;
      }
      
      // @@protoc_insertion_point(builder_scope:box2d.PbWorld)
    }
    
    static {
      defaultInstance = new PbWorld(true);
      defaultInstance.initFields();
    }
    
    // @@protoc_insertion_point(class_scope:box2d.PbWorld)
  }
  
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbVec2_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbVec2_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbFilter_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbFilter_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbShape_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbShape_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbFixture_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbFixture_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbJoint_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbJoint_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbBody_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbBody_fieldAccessorTable;
  private static com.google.protobuf.Descriptors.Descriptor
    internal_static_box2d_PbWorld_descriptor;
  private static
    com.google.protobuf.GeneratedMessage.FieldAccessorTable
      internal_static_box2d_PbWorld_fieldAccessorTable;
  
  public static com.google.protobuf.Descriptors.FileDescriptor
      getDescriptor() {
    return descriptor;
  }
  private static com.google.protobuf.Descriptors.FileDescriptor
      descriptor;
  static {
    java.lang.String[] descriptorData = {
      "\n$src/main/resources/proto/box2d.proto\022\005" +
      "box2d\"\036\n\006PbVec2\022\t\n\001x\030\001 \002(\002\022\t\n\001y\030\002 \002(\002\"I\n" +
      "\010PbFilter\022\025\n\rcategory_bits\030\001 \001(\005\022\021\n\tmask" +
      "_bits\030\002 \001(\005\022\023\n\013group_index\030\003 \001(\005\"\307\001\n\007PbS" +
      "hape\022\013\n\003tag\030\001 \001(\003\022 \n\004type\030\002 \002(\0162\022.box2d." +
      "PbShapeType\022\035\n\006center\030\n \001(\0132\r.box2d.PbVe" +
      "c2\022\016\n\006radius\030\013 \001(\002\022\035\n\006points\030\024 \003(\0132\r.box" +
      "2d.PbVec2\022\036\n\007normals\030\025 \003(\0132\r.box2d.PbVec" +
      "2\022\037\n\010centroid\030\026 \001(\0132\r.box2d.PbVec2\"\240\001\n\tP" +
      "bFixture\022\013\n\003tag\030\001 \001(\003\022\023\n\013restitution\030\002 \001",
      "(\002\022\020\n\010friction\030\003 \001(\002\022\017\n\007density\030\004 \001(\002\022\016\n" +
      "\006sensor\030\005 \001(\010\022\037\n\006filter\030\n \001(\0132\017.box2d.Pb" +
      "Filter\022\035\n\005shape\030\013 \001(\0132\016.box2d.PbShape\"\350\006" +
      "\n\007PbJoint\022\013\n\003tag\030\001 \001(\003\022 \n\004type\030\002 \002(\0162\022.b" +
      "ox2d.PbJointType\022\016\n\006body_a\030\003 \001(\005\022\016\n\006body" +
      "_b\030\004 \001(\005\022\030\n\020collideConnected\030\005 \001(\010\022%\n\016lo" +
      "cal_anchor_a\030\006 \001(\0132\r.box2d.PbVec2\022%\n\016loc" +
      "al_anchor_b\030\007 \001(\0132\r.box2d.PbVec2\022\021\n\tref_" +
      "angle\030\n \001(\002\022\024\n\014enable_limit\030\014 \001(\010\022\023\n\013low" +
      "er_limit\030\r \001(\002\022\023\n\013upper_limit\030\016 \001(\002\022\024\n\014e",
      "nable_motor\030\017 \001(\010\022\023\n\013motor_speed\030\020 \001(\002\022\030" +
      "\n\020max_motor_torque\030\021 \001(\002\022#\n\014local_axis_a" +
      "\030\024 \001(\0132\r.box2d.PbVec2\022\027\n\017max_motor_force" +
      "\030\025 \001(\002\022\016\n\006length\030\036 \001(\002\022\021\n\tfrequency\030\037 \001(" +
      "\002\022\025\n\rdamping_ratio\030  \001(\002\022&\n\017ground_ancho" +
      "r_a\030( \001(\0132\r.box2d.PbVec2\022&\n\017ground_ancho" +
      "r_b\030) \001(\0132\r.box2d.PbVec2\022\020\n\010length_a\030* \001" +
      "(\002\022\020\n\010length_b\030+ \001(\002\022\r\n\005ratio\030, \001(\002\022\024\n\014m" +
      "ax_length_a\030- \001(\002\022\024\n\014max_length_b\030. \001(\002\022" +
      "\035\n\006target\0302 \001(\0132\r.box2d.PbVec2\022\021\n\tmax_fo",
      "rce\0303 \001(\002\022\016\n\006joint1\030= \001(\005\022\016\n\006joint2\030> \001(" +
      "\005\022\030\n\020spring_frequency\030F \001(\002\022\034\n\024spring_da" +
      "mping_ratio\030G \001(\002\022\022\n\nmax_torque\030Z \001(\002\022\022\n" +
      "\nmax_length\030d \001(\002\022\016\n\006bodies\030n \003(\005\022\016\n\006joi" +
      "nts\030o \003(\005\022\025\n\rtarget_volume\030p \001(\002\"\267\003\n\006PbB" +
      "ody\022\013\n\003tag\030\001 \001(\003\022\037\n\004type\030\002 \002(\0162\021.box2d.P" +
      "bBodyType\022\037\n\010position\030\n \001(\0132\r.box2d.PbVe" +
      "c2\022\r\n\005angle\030\013 \001(\002\022&\n\017linear_velocity\030\014 \001" +
      "(\0132\r.box2d.PbVec2\022\030\n\020angular_velocity\030\r " +
      "\001(\002\022\034\n\005force\030\016 \001(\0132\r.box2d.PbVec2\022\016\n\006tor",
      "que\030\017 \001(\002\022\014\n\004mass\030\020 \001(\002\022\t\n\001I\030\021 \001(\002\022\026\n\016li" +
      "near_damping\0302 \001(\002\022\027\n\017angular_damping\0303 " +
      "\001(\002\022\025\n\rgravity_scale\0304 \001(\002\022\016\n\006bullet\0305 \001" +
      "(\010\022\023\n\013allow_sleep\0306 \001(\010\022\r\n\005awake\0307 \001(\010\022\016" +
      "\n\006active\0308 \001(\010\022\026\n\016fixed_rotation\0309 \001(\010\022\"" +
      "\n\010fixtures\030d \003(\0132\020.box2d.PbFixture\"\356\001\n\007P" +
      "bWorld\022\013\n\003tag\030\001 \001(\003\022\036\n\007gravity\030\002 \001(\0132\r.b" +
      "ox2d.PbVec2\022\023\n\013allow_sleep\030\003 \001(\010\022\031\n\021auto" +
      "_clear_forces\030\004 \001(\010\022\025\n\rwarm_starting\030\005 \001" +
      "(\010\022\032\n\022continuous_physics\030\006 \001(\010\022\024\n\014sub_st",
      "epping\030\007 \001(\010\022\035\n\006bodies\030\024 \003(\0132\r.box2d.PbB" +
      "ody\022\036\n\006joints\030\025 \003(\0132\016.box2d.PbJoint*4\n\nP" +
      "bBodyType\022\n\n\006STATIC\020\000\022\013\n\007DYNAMIC\020\001\022\r\n\tKI" +
      "NEMATIC\020\002*:\n\013PbShapeType\022\n\n\006CIRCLE\020\001\022\013\n\007" +
      "POLYGON\020\002\022\010\n\004EDGE\020\003\022\010\n\004LOOP\020\004*\245\001\n\013PbJoin" +
      "tType\022\014\n\010DISTANCE\020\001\022\014\n\010REVOLUTE\020\002\022\r\n\tPRI" +
      "SMATIC\020\003\022\n\n\006PULLEY\020\004\022\t\n\005MOUSE\020\005\022\010\n\004GEAR\020" +
      "\006\022\t\n\005WHEEL\020\007\022\010\n\004WELD\020\010\022\014\n\010FRICTION\020\t\022\010\n\004" +
      "ROPE\020\n\022\023\n\017CONSTANT_VOLUME\020\013\022\010\n\004LINE\020\014B\030\n" +
      "\017org.box2d.protoB\005Box2D"
    };
    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
      new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
        public com.google.protobuf.ExtensionRegistry assignDescriptors(
            com.google.protobuf.Descriptors.FileDescriptor root) {
          descriptor = root;
          internal_static_box2d_PbVec2_descriptor =
            getDescriptor().getMessageTypes().get(0);
          internal_static_box2d_PbVec2_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbVec2_descriptor,
              new java.lang.String[] { "X", "Y", },
              org.box2d.proto.Box2D.PbVec2.class,
              org.box2d.proto.Box2D.PbVec2.Builder.class);
          internal_static_box2d_PbFilter_descriptor =
            getDescriptor().getMessageTypes().get(1);
          internal_static_box2d_PbFilter_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbFilter_descriptor,
              new java.lang.String[] { "CategoryBits", "MaskBits", "GroupIndex", },
              org.box2d.proto.Box2D.PbFilter.class,
              org.box2d.proto.Box2D.PbFilter.Builder.class);
          internal_static_box2d_PbShape_descriptor =
            getDescriptor().getMessageTypes().get(2);
          internal_static_box2d_PbShape_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbShape_descriptor,
              new java.lang.String[] { "Tag", "Type", "Center", "Radius", "Points", "Normals", "Centroid", },
              org.box2d.proto.Box2D.PbShape.class,
              org.box2d.proto.Box2D.PbShape.Builder.class);
          internal_static_box2d_PbFixture_descriptor =
            getDescriptor().getMessageTypes().get(3);
          internal_static_box2d_PbFixture_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbFixture_descriptor,
              new java.lang.String[] { "Tag", "Restitution", "Friction", "Density", "Sensor", "Filter", "Shape", },
              org.box2d.proto.Box2D.PbFixture.class,
              org.box2d.proto.Box2D.PbFixture.Builder.class);
          internal_static_box2d_PbJoint_descriptor =
            getDescriptor().getMessageTypes().get(4);
          internal_static_box2d_PbJoint_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbJoint_descriptor,
              new java.lang.String[] { "Tag", "Type", "BodyA", "BodyB", "CollideConnected", "LocalAnchorA", "LocalAnchorB", "RefAngle", "EnableLimit", "LowerLimit", "UpperLimit", "EnableMotor", "MotorSpeed", "MaxMotorTorque", "LocalAxisA", "MaxMotorForce", "Length", "Frequency", "DampingRatio", "GroundAnchorA", "GroundAnchorB", "LengthA", "LengthB", "Ratio", "MaxLengthA", "MaxLengthB", "Target", "MaxForce", "Joint1", "Joint2", "SpringFrequency", "SpringDampingRatio", "MaxTorque", "MaxLength", "Bodies", "Joints", "TargetVolume", },
              org.box2d.proto.Box2D.PbJoint.class,
              org.box2d.proto.Box2D.PbJoint.Builder.class);
          internal_static_box2d_PbBody_descriptor =
            getDescriptor().getMessageTypes().get(5);
          internal_static_box2d_PbBody_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbBody_descriptor,
              new java.lang.String[] { "Tag", "Type", "Position", "Angle", "LinearVelocity", "AngularVelocity", "Force", "Torque", "Mass", "I", "LinearDamping", "AngularDamping", "GravityScale", "Bullet", "AllowSleep", "Awake", "Active", "FixedRotation", "Fixtures", },
              org.box2d.proto.Box2D.PbBody.class,
              org.box2d.proto.Box2D.PbBody.Builder.class);
          internal_static_box2d_PbWorld_descriptor =
            getDescriptor().getMessageTypes().get(6);
          internal_static_box2d_PbWorld_fieldAccessorTable = new
            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
              internal_static_box2d_PbWorld_descriptor,
              new java.lang.String[] { "Tag", "Gravity", "AllowSleep", "AutoClearForces", "WarmStarting", "ContinuousPhysics", "SubStepping", "Bodies", "Joints", },
              org.box2d.proto.Box2D.PbWorld.class,
              org.box2d.proto.Box2D.PbWorld.Builder.class);
          return null;
        }
      }