pbjs/test.proto.es5.js

A minimal implementation of Google Protocol Buffers for JavaScript

exports.encodeEnum = {
  A: 0,
  B: 1,
};

exports.decodeEnum = {
  0: "A",
  1: "B",
};

exports.encodeNested = function (message) {
  var bb = popByteBuffer();
  _encodeNested(message, bb);
  return toUint8Array(bb);
}

function _encodeNested(message, bb) {
  // optional float x = 1;
  var $x = message.x;
  if ($x !== undefined) {
    writeVarint32(bb, 13);
    writeFloat(bb, $x);
  }

  // optional float y = 2;
  var $y = message.y;
  if ($y !== undefined) {
    writeVarint32(bb, 21);
    writeFloat(bb, $y);
  }
};

exports.decodeNested = function (binary) {
  return _decodeNested(wrapByteBuffer(binary));
}

function _decodeNested(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // optional float x = 1;
      case 1: {
        message.x = readFloat(bb);
        break;
      }

      // optional float y = 2;
      case 2: {
        message.y = readFloat(bb);
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
};

exports.encodeOptional = function (message) {
  var bb = popByteBuffer();
  _encodeOptional(message, bb);
  return toUint8Array(bb);
}

function _encodeOptional(message, bb) {
  // optional int32 field_int32 = 1;
  var $field_int32 = message.field_int32;
  if ($field_int32 !== undefined) {
    writeVarint32(bb, 8);
    writeVarint64(bb, intToLong($field_int32));
  }

  // optional int64 field_int64 = 2;
  var $field_int64 = message.field_int64;
  if ($field_int64 !== undefined) {
    writeVarint32(bb, 16);
    writeVarint64(bb, $field_int64);
  }

  // optional uint32 field_uint32 = 3;
  var $field_uint32 = message.field_uint32;
  if ($field_uint32 !== undefined) {
    writeVarint32(bb, 24);
    writeVarint32(bb, $field_uint32);
  }

  // optional uint64 field_uint64 = 4;
  var $field_uint64 = message.field_uint64;
  if ($field_uint64 !== undefined) {
    writeVarint32(bb, 32);
    writeVarint64(bb, $field_uint64);
  }

  // optional sint32 field_sint32 = 5;
  var $field_sint32 = message.field_sint32;
  if ($field_sint32 !== undefined) {
    writeVarint32(bb, 40);
    writeVarint32ZigZag(bb, $field_sint32);
  }

  // optional sint64 field_sint64 = 6;
  var $field_sint64 = message.field_sint64;
  if ($field_sint64 !== undefined) {
    writeVarint32(bb, 48);
    writeVarint64ZigZag(bb, $field_sint64);
  }

  // optional bool field_bool = 7;
  var $field_bool = message.field_bool;
  if ($field_bool !== undefined) {
    writeVarint32(bb, 56);
    writeByte(bb, $field_bool ? 1 : 0);
  }

  // optional fixed64 field_fixed64 = 8;
  var $field_fixed64 = message.field_fixed64;
  if ($field_fixed64 !== undefined) {
    writeVarint32(bb, 65);
    writeInt64(bb, $field_fixed64);
  }

  // optional sfixed64 field_sfixed64 = 9;
  var $field_sfixed64 = message.field_sfixed64;
  if ($field_sfixed64 !== undefined) {
    writeVarint32(bb, 73);
    writeInt64(bb, $field_sfixed64);
  }

  // optional double field_double = 10;
  var $field_double = message.field_double;
  if ($field_double !== undefined) {
    writeVarint32(bb, 81);
    writeDouble(bb, $field_double);
  }

  // optional string field_string = 11;
  var $field_string = message.field_string;
  if ($field_string !== undefined) {
    writeVarint32(bb, 90);
    writeString(bb, $field_string);
  }

  // optional bytes field_bytes = 12;
  var $field_bytes = message.field_bytes;
  if ($field_bytes !== undefined) {
    writeVarint32(bb, 98);
    writeVarint32(bb, $field_bytes.length), writeBytes(bb, $field_bytes);
  }

  // optional fixed32 field_fixed32 = 13;
  var $field_fixed32 = message.field_fixed32;
  if ($field_fixed32 !== undefined) {
    writeVarint32(bb, 109);
    writeInt32(bb, $field_fixed32);
  }

  // optional sfixed32 field_sfixed32 = 14;
  var $field_sfixed32 = message.field_sfixed32;
  if ($field_sfixed32 !== undefined) {
    writeVarint32(bb, 117);
    writeInt32(bb, $field_sfixed32);
  }

  // optional float field_float = 15;
  var $field_float = message.field_float;
  if ($field_float !== undefined) {
    writeVarint32(bb, 125);
    writeFloat(bb, $field_float);
  }

  // optional Nested field_nested = 16;
  var $field_nested = message.field_nested;
  if ($field_nested !== undefined) {
    writeVarint32(bb, 130);
    var nested = popByteBuffer();
    _encodeNested($field_nested, nested);
    writeVarint32(bb, nested.limit);
    writeByteBuffer(bb, nested);
    pushByteBuffer(nested);
  }
};

exports.decodeOptional = function (binary) {
  return _decodeOptional(wrapByteBuffer(binary));
}

function _decodeOptional(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // optional int32 field_int32 = 1;
      case 1: {
        message.field_int32 = readVarint32(bb);
        break;
      }

      // optional int64 field_int64 = 2;
      case 2: {
        message.field_int64 = readVarint64(bb, /* unsigned */ false);
        break;
      }

      // optional uint32 field_uint32 = 3;
      case 3: {
        message.field_uint32 = readVarint32(bb) >>> 0;
        break;
      }

      // optional uint64 field_uint64 = 4;
      case 4: {
        message.field_uint64 = readVarint64(bb, /* unsigned */ true);
        break;
      }

      // optional sint32 field_sint32 = 5;
      case 5: {
        message.field_sint32 = readVarint32ZigZag(bb);
        break;
      }

      // optional sint64 field_sint64 = 6;
      case 6: {
        message.field_sint64 = readVarint64ZigZag(bb);
        break;
      }

      // optional bool field_bool = 7;
      case 7: {
        message.field_bool = !!readByte(bb);
        break;
      }

      // optional fixed64 field_fixed64 = 8;
      case 8: {
        message.field_fixed64 = readInt64(bb, /* unsigned */ true);
        break;
      }

      // optional sfixed64 field_sfixed64 = 9;
      case 9: {
        message.field_sfixed64 = readInt64(bb, /* unsigned */ false);
        break;
      }

      // optional double field_double = 10;
      case 10: {
        message.field_double = readDouble(bb);
        break;
      }

      // optional string field_string = 11;
      case 11: {
        message.field_string = readString(bb, readVarint32(bb));
        break;
      }

      // optional bytes field_bytes = 12;
      case 12: {
        message.field_bytes = readBytes(bb, readVarint32(bb));
        break;
      }

      // optional fixed32 field_fixed32 = 13;
      case 13: {
        message.field_fixed32 = readInt32(bb) >>> 0;
        break;
      }

      // optional sfixed32 field_sfixed32 = 14;
      case 14: {
        message.field_sfixed32 = readInt32(bb);
        break;
      }

      // optional float field_float = 15;
      case 15: {
        message.field_float = readFloat(bb);
        break;
      }

      // optional Nested field_nested = 16;
      case 16: {
        var limit = pushTemporaryLength(bb);
        message.field_nested = _decodeNested(bb);
        bb.limit = limit;
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
};

exports.encodeRepeatedUnpacked = function (message) {
  var bb = popByteBuffer();
  _encodeRepeatedUnpacked(message, bb);
  return toUint8Array(bb);
}

function _encodeRepeatedUnpacked(message, bb) {
  // repeated int32 field_int32 = 1;
  var array$field_int32 = message.field_int32;
  if (array$field_int32 !== undefined) {
    for (var i = 0; i < array$field_int32.length; i++) {
      var value = array$field_int32[i];
      writeVarint32(bb, 8);
      writeVarint64(bb, intToLong(value));
    }
  }

  // repeated int64 field_int64 = 2;
  var array$field_int64 = message.field_int64;
  if (array$field_int64 !== undefined) {
    for (var i = 0; i < array$field_int64.length; i++) {
      var value = array$field_int64[i];
      writeVarint32(bb, 16);
      writeVarint64(bb, value);
    }
  }

  // repeated uint32 field_uint32 = 3;
  var array$field_uint32 = message.field_uint32;
  if (array$field_uint32 !== undefined) {
    for (var i = 0; i < array$field_uint32.length; i++) {
      var value = array$field_uint32[i];
      writeVarint32(bb, 24);
      writeVarint32(bb, value);
    }
  }

  // repeated uint64 field_uint64 = 4;
  var array$field_uint64 = message.field_uint64;
  if (array$field_uint64 !== undefined) {
    for (var i = 0; i < array$field_uint64.length; i++) {
      var value = array$field_uint64[i];
      writeVarint32(bb, 32);
      writeVarint64(bb, value);
    }
  }

  // repeated sint32 field_sint32 = 5;
  var array$field_sint32 = message.field_sint32;
  if (array$field_sint32 !== undefined) {
    for (var i = 0; i < array$field_sint32.length; i++) {
      var value = array$field_sint32[i];
      writeVarint32(bb, 40);
      writeVarint32ZigZag(bb, value);
    }
  }

  // repeated sint64 field_sint64 = 6;
  var array$field_sint64 = message.field_sint64;
  if (array$field_sint64 !== undefined) {
    for (var i = 0; i < array$field_sint64.length; i++) {
      var value = array$field_sint64[i];
      writeVarint32(bb, 48);
      writeVarint64ZigZag(bb, value);
    }
  }

  // repeated bool field_bool = 7;
  var array$field_bool = message.field_bool;
  if (array$field_bool !== undefined) {
    for (var i = 0; i < array$field_bool.length; i++) {
      var value = array$field_bool[i];
      writeVarint32(bb, 56);
      writeByte(bb, value ? 1 : 0);
    }
  }

  // repeated fixed64 field_fixed64 = 8;
  var array$field_fixed64 = message.field_fixed64;
  if (array$field_fixed64 !== undefined) {
    for (var i = 0; i < array$field_fixed64.length; i++) {
      var value = array$field_fixed64[i];
      writeVarint32(bb, 65);
      writeInt64(bb, value);
    }
  }

  // repeated sfixed64 field_sfixed64 = 9;
  var array$field_sfixed64 = message.field_sfixed64;
  if (array$field_sfixed64 !== undefined) {
    for (var i = 0; i < array$field_sfixed64.length; i++) {
      var value = array$field_sfixed64[i];
      writeVarint32(bb, 73);
      writeInt64(bb, value);
    }
  }

  // repeated double field_double = 10;
  var array$field_double = message.field_double;
  if (array$field_double !== undefined) {
    for (var i = 0; i < array$field_double.length; i++) {
      var value = array$field_double[i];
      writeVarint32(bb, 81);
      writeDouble(bb, value);
    }
  }

  // repeated string field_string = 11;
  var array$field_string = message.field_string;
  if (array$field_string !== undefined) {
    for (var i = 0; i < array$field_string.length; i++) {
      var value = array$field_string[i];
      writeVarint32(bb, 90);
      writeString(bb, value);
    }
  }

  // repeated bytes field_bytes = 12;
  var array$field_bytes = message.field_bytes;
  if (array$field_bytes !== undefined) {
    for (var i = 0; i < array$field_bytes.length; i++) {
      var value = array$field_bytes[i];
      writeVarint32(bb, 98);
      writeVarint32(bb, value.length), writeBytes(bb, value);
    }
  }

  // repeated fixed32 field_fixed32 = 13;
  var array$field_fixed32 = message.field_fixed32;
  if (array$field_fixed32 !== undefined) {
    for (var i = 0; i < array$field_fixed32.length; i++) {
      var value = array$field_fixed32[i];
      writeVarint32(bb, 109);
      writeInt32(bb, value);
    }
  }

  // repeated sfixed32 field_sfixed32 = 14;
  var array$field_sfixed32 = message.field_sfixed32;
  if (array$field_sfixed32 !== undefined) {
    for (var i = 0; i < array$field_sfixed32.length; i++) {
      var value = array$field_sfixed32[i];
      writeVarint32(bb, 117);
      writeInt32(bb, value);
    }
  }

  // repeated float field_float = 15;
  var array$field_float = message.field_float;
  if (array$field_float !== undefined) {
    for (var i = 0; i < array$field_float.length; i++) {
      var value = array$field_float[i];
      writeVarint32(bb, 125);
      writeFloat(bb, value);
    }
  }

  // repeated Nested field_nested = 16;
  var array$field_nested = message.field_nested;
  if (array$field_nested !== undefined) {
    for (var i = 0; i < array$field_nested.length; i++) {
      var value = array$field_nested[i];
      writeVarint32(bb, 130);
      var nested = popByteBuffer();
      _encodeNested(value, nested);
      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
};

exports.decodeRepeatedUnpacked = function (binary) {
  return _decodeRepeatedUnpacked(wrapByteBuffer(binary));
}

function _decodeRepeatedUnpacked(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // repeated int32 field_int32 = 1;
      case 1: {
        var values = message.field_int32 || (message.field_int32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32(bb));
        }
        break;
      }

      // repeated int64 field_int64 = 2;
      case 2: {
        var values = message.field_int64 || (message.field_int64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64(bb, /* unsigned */ false));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64(bb, /* unsigned */ false));
        }
        break;
      }

      // repeated uint32 field_uint32 = 3;
      case 3: {
        var values = message.field_uint32 || (message.field_uint32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32(bb) >>> 0);
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32(bb) >>> 0);
        }
        break;
      }

      // repeated uint64 field_uint64 = 4;
      case 4: {
        var values = message.field_uint64 || (message.field_uint64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64(bb, /* unsigned */ true));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64(bb, /* unsigned */ true));
        }
        break;
      }

      // repeated sint32 field_sint32 = 5;
      case 5: {
        var values = message.field_sint32 || (message.field_sint32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32ZigZag(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32ZigZag(bb));
        }
        break;
      }

      // repeated sint64 field_sint64 = 6;
      case 6: {
        var values = message.field_sint64 || (message.field_sint64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64ZigZag(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64ZigZag(bb));
        }
        break;
      }

      // repeated bool field_bool = 7;
      case 7: {
        var values = message.field_bool || (message.field_bool = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(!!readByte(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(!!readByte(bb));
        }
        break;
      }

      // repeated fixed64 field_fixed64 = 8;
      case 8: {
        var values = message.field_fixed64 || (message.field_fixed64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt64(bb, /* unsigned */ true));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt64(bb, /* unsigned */ true));
        }
        break;
      }

      // repeated sfixed64 field_sfixed64 = 9;
      case 9: {
        var values = message.field_sfixed64 || (message.field_sfixed64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt64(bb, /* unsigned */ false));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt64(bb, /* unsigned */ false));
        }
        break;
      }

      // repeated double field_double = 10;
      case 10: {
        var values = message.field_double || (message.field_double = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readDouble(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readDouble(bb));
        }
        break;
      }

      // repeated string field_string = 11;
      case 11: {
        var values = message.field_string || (message.field_string = []);
        values.push(readString(bb, readVarint32(bb)));
        break;
      }

      // repeated bytes field_bytes = 12;
      case 12: {
        var values = message.field_bytes || (message.field_bytes = []);
        values.push(readBytes(bb, readVarint32(bb)));
        break;
      }

      // repeated fixed32 field_fixed32 = 13;
      case 13: {
        var values = message.field_fixed32 || (message.field_fixed32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt32(bb) >>> 0);
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt32(bb) >>> 0);
        }
        break;
      }

      // repeated sfixed32 field_sfixed32 = 14;
      case 14: {
        var values = message.field_sfixed32 || (message.field_sfixed32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt32(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt32(bb));
        }
        break;
      }

      // repeated float field_float = 15;
      case 15: {
        var values = message.field_float || (message.field_float = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readFloat(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readFloat(bb));
        }
        break;
      }

      // repeated Nested field_nested = 16;
      case 16: {
        var limit = pushTemporaryLength(bb);
        var values = message.field_nested || (message.field_nested = []);
        values.push(_decodeNested(bb));
        bb.limit = limit;
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
};

exports.encodeRepeatedPacked = function (message) {
  var bb = popByteBuffer();
  _encodeRepeatedPacked(message, bb);
  return toUint8Array(bb);
}

function _encodeRepeatedPacked(message, bb) {
  // repeated int32 field_int32 = 1;
  var array$field_int32 = message.field_int32;
  if (array$field_int32 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_int32.length; i++) {
      var value = array$field_int32[i];
      writeVarint64(packed, intToLong(value));
    }
    writeVarint32(bb, 10);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated int64 field_int64 = 2;
  var array$field_int64 = message.field_int64;
  if (array$field_int64 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_int64.length; i++) {
      var value = array$field_int64[i];
      writeVarint64(packed, value);
    }
    writeVarint32(bb, 18);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated uint32 field_uint32 = 3;
  var array$field_uint32 = message.field_uint32;
  if (array$field_uint32 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_uint32.length; i++) {
      var value = array$field_uint32[i];
      writeVarint32(packed, value);
    }
    writeVarint32(bb, 26);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated uint64 field_uint64 = 4;
  var array$field_uint64 = message.field_uint64;
  if (array$field_uint64 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_uint64.length; i++) {
      var value = array$field_uint64[i];
      writeVarint64(packed, value);
    }
    writeVarint32(bb, 34);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated sint32 field_sint32 = 5;
  var array$field_sint32 = message.field_sint32;
  if (array$field_sint32 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_sint32.length; i++) {
      var value = array$field_sint32[i];
      writeVarint32ZigZag(packed, value);
    }
    writeVarint32(bb, 42);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated sint64 field_sint64 = 6;
  var array$field_sint64 = message.field_sint64;
  if (array$field_sint64 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_sint64.length; i++) {
      var value = array$field_sint64[i];
      writeVarint64ZigZag(packed, value);
    }
    writeVarint32(bb, 50);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated bool field_bool = 7;
  var array$field_bool = message.field_bool;
  if (array$field_bool !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_bool.length; i++) {
      var value = array$field_bool[i];
      writeByte(packed, value ? 1 : 0);
    }
    writeVarint32(bb, 58);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated fixed64 field_fixed64 = 8;
  var array$field_fixed64 = message.field_fixed64;
  if (array$field_fixed64 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_fixed64.length; i++) {
      var value = array$field_fixed64[i];
      writeInt64(packed, value);
    }
    writeVarint32(bb, 66);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated sfixed64 field_sfixed64 = 9;
  var array$field_sfixed64 = message.field_sfixed64;
  if (array$field_sfixed64 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_sfixed64.length; i++) {
      var value = array$field_sfixed64[i];
      writeInt64(packed, value);
    }
    writeVarint32(bb, 74);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated double field_double = 10;
  var array$field_double = message.field_double;
  if (array$field_double !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_double.length; i++) {
      var value = array$field_double[i];
      writeDouble(packed, value);
    }
    writeVarint32(bb, 82);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated string field_string = 11;
  var array$field_string = message.field_string;
  if (array$field_string !== undefined) {
    for (var i = 0; i < array$field_string.length; i++) {
      var value = array$field_string[i];
      writeVarint32(bb, 90);
      writeString(bb, value);
    }
  }

  // repeated bytes field_bytes = 12;
  var array$field_bytes = message.field_bytes;
  if (array$field_bytes !== undefined) {
    for (var i = 0; i < array$field_bytes.length; i++) {
      var value = array$field_bytes[i];
      writeVarint32(bb, 98);
      writeVarint32(bb, value.length), writeBytes(bb, value);
    }
  }

  // repeated fixed32 field_fixed32 = 13;
  var array$field_fixed32 = message.field_fixed32;
  if (array$field_fixed32 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_fixed32.length; i++) {
      var value = array$field_fixed32[i];
      writeInt32(packed, value);
    }
    writeVarint32(bb, 106);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated sfixed32 field_sfixed32 = 14;
  var array$field_sfixed32 = message.field_sfixed32;
  if (array$field_sfixed32 !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_sfixed32.length; i++) {
      var value = array$field_sfixed32[i];
      writeInt32(packed, value);
    }
    writeVarint32(bb, 114);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated float field_float = 15;
  var array$field_float = message.field_float;
  if (array$field_float !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$field_float.length; i++) {
      var value = array$field_float[i];
      writeFloat(packed, value);
    }
    writeVarint32(bb, 122);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }

  // repeated Nested field_nested = 16;
  var array$field_nested = message.field_nested;
  if (array$field_nested !== undefined) {
    for (var i = 0; i < array$field_nested.length; i++) {
      var value = array$field_nested[i];
      writeVarint32(bb, 130);
      var nested = popByteBuffer();
      _encodeNested(value, nested);
      writeVarint32(bb, nested.limit);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
};

exports.decodeRepeatedPacked = function (binary) {
  return _decodeRepeatedPacked(wrapByteBuffer(binary));
}

function _decodeRepeatedPacked(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // repeated int32 field_int32 = 1;
      case 1: {
        var values = message.field_int32 || (message.field_int32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32(bb));
        }
        break;
      }

      // repeated int64 field_int64 = 2;
      case 2: {
        var values = message.field_int64 || (message.field_int64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64(bb, /* unsigned */ false));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64(bb, /* unsigned */ false));
        }
        break;
      }

      // repeated uint32 field_uint32 = 3;
      case 3: {
        var values = message.field_uint32 || (message.field_uint32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32(bb) >>> 0);
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32(bb) >>> 0);
        }
        break;
      }

      // repeated uint64 field_uint64 = 4;
      case 4: {
        var values = message.field_uint64 || (message.field_uint64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64(bb, /* unsigned */ true));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64(bb, /* unsigned */ true));
        }
        break;
      }

      // repeated sint32 field_sint32 = 5;
      case 5: {
        var values = message.field_sint32 || (message.field_sint32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint32ZigZag(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint32ZigZag(bb));
        }
        break;
      }

      // repeated sint64 field_sint64 = 6;
      case 6: {
        var values = message.field_sint64 || (message.field_sint64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readVarint64ZigZag(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readVarint64ZigZag(bb));
        }
        break;
      }

      // repeated bool field_bool = 7;
      case 7: {
        var values = message.field_bool || (message.field_bool = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(!!readByte(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(!!readByte(bb));
        }
        break;
      }

      // repeated fixed64 field_fixed64 = 8;
      case 8: {
        var values = message.field_fixed64 || (message.field_fixed64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt64(bb, /* unsigned */ true));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt64(bb, /* unsigned */ true));
        }
        break;
      }

      // repeated sfixed64 field_sfixed64 = 9;
      case 9: {
        var values = message.field_sfixed64 || (message.field_sfixed64 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt64(bb, /* unsigned */ false));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt64(bb, /* unsigned */ false));
        }
        break;
      }

      // repeated double field_double = 10;
      case 10: {
        var values = message.field_double || (message.field_double = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readDouble(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readDouble(bb));
        }
        break;
      }

      // repeated string field_string = 11;
      case 11: {
        var values = message.field_string || (message.field_string = []);
        values.push(readString(bb, readVarint32(bb)));
        break;
      }

      // repeated bytes field_bytes = 12;
      case 12: {
        var values = message.field_bytes || (message.field_bytes = []);
        values.push(readBytes(bb, readVarint32(bb)));
        break;
      }

      // repeated fixed32 field_fixed32 = 13;
      case 13: {
        var values = message.field_fixed32 || (message.field_fixed32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt32(bb) >>> 0);
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt32(bb) >>> 0);
        }
        break;
      }

      // repeated sfixed32 field_sfixed32 = 14;
      case 14: {
        var values = message.field_sfixed32 || (message.field_sfixed32 = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readInt32(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readInt32(bb));
        }
        break;
      }

      // repeated float field_float = 15;
      case 15: {
        var values = message.field_float || (message.field_float = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(readFloat(bb));
          }
          bb.limit = outerLimit;
        } else {
          values.push(readFloat(bb));
        }
        break;
      }

      // repeated Nested field_nested = 16;
      case 16: {
        var limit = pushTemporaryLength(bb);
        var values = message.field_nested || (message.field_nested = []);
        values.push(_decodeNested(bb));
        bb.limit = limit;
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
};

exports.encodeEnumTest = function (message) {
  var bb = popByteBuffer();
  _encodeEnumTest(message, bb);
  return toUint8Array(bb);
}

function _encodeEnumTest(message, bb) {
  // optional Enum a = 1;
  var $a = message.a;
  if ($a !== undefined) {
    writeVarint32(bb, 8);
    writeVarint32(bb, exports.encodeEnum[$a]);
  }

  // required Enum b = 2;
  var $b = message.b;
  if ($b !== undefined) {
    writeVarint32(bb, 16);
    writeVarint32(bb, exports.encodeEnum[$b]);
  }

  // repeated Enum c = 3;
  var array$c = message.c;
  if (array$c !== undefined) {
    var packed = popByteBuffer();
    for (var i = 0; i < array$c.length; i++) {
      var value = array$c[i];
      writeVarint32(packed, exports.encodeEnum[value]);
    }
    writeVarint32(bb, 26);
    writeVarint32(bb, packed.offset);
    writeByteBuffer(bb, packed);
    pushByteBuffer(packed);
  }
};

exports.decodeEnumTest = function (binary) {
  return _decodeEnumTest(wrapByteBuffer(binary));
}

function _decodeEnumTest(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // optional Enum a = 1;
      case 1: {
        message.a = exports.decodeEnum[readVarint32(bb)];
        break;
      }

      // required Enum b = 2;
      case 2: {
        message.b = exports.decodeEnum[readVarint32(bb)];
        break;
      }

      // repeated Enum c = 3;
      case 3: {
        var values = message.c || (message.c = []);
        if ((tag & 7) === 2) {
          var outerLimit = pushTemporaryLength(bb);
          while (!isAtEnd(bb)) {
            values.push(exports.decodeEnum[readVarint32(bb)]);
          }
          bb.limit = outerLimit;
        } else {
          values.push(exports.decodeEnum[readVarint32(bb)]);
        }
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  if (message.b === undefined)
    throw new Error("Missing required field: b");

  return message;
};

exports.encodeMapTestIntAndString = function (message) {
  var bb = popByteBuffer();
  _encodeMapTestIntAndString(message, bb);
  return toUint8Array(bb);
}

function _encodeMapTestIntAndString(message, bb) {
  // optional map<int32, string> field_int32 = 1;
  var map$field_int32 = message.field_int32;
  if (map$field_int32 !== undefined) {
    for (var key in map$field_int32) {
      var nested = popByteBuffer();
      var value = map$field_int32[key];
      writeVarint32(nested, 8);
      writeVarint64(nested, intToLong(+key));
      writeVarint32(nested, 18);
      writeString(nested, value);
      writeVarint32(bb, 10);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<uint32, bytes> field_uint32 = 2;
  var map$field_uint32 = message.field_uint32;
  if (map$field_uint32 !== undefined) {
    for (var key in map$field_uint32) {
      var nested = popByteBuffer();
      var value = map$field_uint32[key];
      writeVarint32(nested, 8);
      writeVarint32(nested, +key);
      writeVarint32(nested, 18);
      writeVarint32(nested, value.length), writeBytes(nested, value);
      writeVarint32(bb, 18);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<sint32, int64> field_sint32 = 3;
  var map$field_sint32 = message.field_sint32;
  if (map$field_sint32 !== undefined) {
    for (var key in map$field_sint32) {
      var nested = popByteBuffer();
      var value = map$field_sint32[key];
      writeVarint32(nested, 8);
      writeVarint32ZigZag(nested, +key);
      writeVarint32(nested, 16);
      writeVarint64(nested, value);
      writeVarint32(bb, 26);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<string, double> field_string = 5;
  var map$field_string = message.field_string;
  if (map$field_string !== undefined) {
    for (var key in map$field_string) {
      var nested = popByteBuffer();
      var value = map$field_string[key];
      writeVarint32(nested, 10);
      writeString(nested, key);
      writeVarint32(nested, 17);
      writeDouble(nested, value);
      writeVarint32(bb, 42);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<fixed32, bool> field_fixed32 = 6;
  var map$field_fixed32 = message.field_fixed32;
  if (map$field_fixed32 !== undefined) {
    for (var key in map$field_fixed32) {
      var nested = popByteBuffer();
      var value = map$field_fixed32[key];
      writeVarint32(nested, 13);
      writeInt32(nested, +key);
      writeVarint32(nested, 16);
      writeByte(nested, value ? 1 : 0);
      writeVarint32(bb, 50);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<sfixed32, Nested> field_sfixed32 = 7;
  var map$field_sfixed32 = message.field_sfixed32;
  if (map$field_sfixed32 !== undefined) {
    for (var key in map$field_sfixed32) {
      var nested = popByteBuffer();
      var value = map$field_sfixed32[key];
      writeVarint32(nested, 13);
      writeInt32(nested, +key);
      writeVarint32(nested, 18);
      var nestedValue = popByteBuffer();
      _encodeNested(value, nestedValue);
      writeVarint32(nested, nestedValue.limit);
      writeByteBuffer(nested, nestedValue);
      pushByteBuffer(nestedValue);
      writeVarint32(bb, 58);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
};

exports.decodeMapTestIntAndString = function (binary) {
  return _decodeMapTestIntAndString(wrapByteBuffer(binary));
}

function _decodeMapTestIntAndString(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // optional map<int32, string> field_int32 = 1;
      case 1: {
        var values = message.field_int32 || (message.field_int32 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readVarint32(bb);
              break;
            }
            case 2: {
              value = readString(bb, readVarint32(bb));
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_int32");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<uint32, bytes> field_uint32 = 2;
      case 2: {
        var values = message.field_uint32 || (message.field_uint32 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readVarint32(bb) >>> 0;
              break;
            }
            case 2: {
              value = readBytes(bb, readVarint32(bb));
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_uint32");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<sint32, int64> field_sint32 = 3;
      case 3: {
        var values = message.field_sint32 || (message.field_sint32 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readVarint32ZigZag(bb);
              break;
            }
            case 2: {
              value = readVarint64(bb, /* unsigned */ false);
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_sint32");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<string, double> field_string = 5;
      case 5: {
        var values = message.field_string || (message.field_string = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readString(bb, readVarint32(bb));
              break;
            }
            case 2: {
              value = readDouble(bb);
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_string");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<fixed32, bool> field_fixed32 = 6;
      case 6: {
        var values = message.field_fixed32 || (message.field_fixed32 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readInt32(bb) >>> 0;
              break;
            }
            case 2: {
              value = !!readByte(bb);
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_fixed32");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<sfixed32, Nested> field_sfixed32 = 7;
      case 7: {
        var values = message.field_sfixed32 || (message.field_sfixed32 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readInt32(bb);
              break;
            }
            case 2: {
              var valueLimit = pushTemporaryLength(bb);
              value = _decodeNested(bb);
              bb.limit = valueLimit;
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_sfixed32");
        values[key] = value;
        bb.limit = outerLimit;
        break;
      }

      default:
        skipUnknownField(bb, tag & 7);
    }
  }

  return message;
};

exports.encodeMapTestLongAndBool = function (message) {
  var bb = popByteBuffer();
  _encodeMapTestLongAndBool(message, bb);
  return toUint8Array(bb);
}

function _encodeMapTestLongAndBool(message, bb) {
  // optional map<int64, string> field_int64 = 1;
  var map$field_int64 = message.field_int64;
  if (map$field_int64 !== undefined) {
    for (var key in map$field_int64) {
      var nested = popByteBuffer();
      var value = map$field_int64[key];
      writeVarint32(nested, 8);
      writeVarint64(nested, stringToLong(key));
      writeVarint32(nested, 18);
      writeString(nested, value);
      writeVarint32(bb, 10);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<uint64, bytes> field_uint64 = 2;
  var map$field_uint64 = message.field_uint64;
  if (map$field_uint64 !== undefined) {
    for (var key in map$field_uint64) {
      var nested = popByteBuffer();
      var value = map$field_uint64[key];
      writeVarint32(nested, 8);
      writeVarint64(nested, stringToLong(key));
      writeVarint32(nested, 18);
      writeVarint32(nested, value.length), writeBytes(nested, value);
      writeVarint32(bb, 18);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<sint64, int64> field_sint64 = 3;
  var map$field_sint64 = message.field_sint64;
  if (map$field_sint64 !== undefined) {
    for (var key in map$field_sint64) {
      var nested = popByteBuffer();
      var value = map$field_sint64[key];
      writeVarint32(nested, 8);
      writeVarint64ZigZag(nested, stringToLong(key));
      writeVarint32(nested, 16);
      writeVarint64(nested, value);
      writeVarint32(bb, 26);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<fixed64, double> field_fixed64 = 4;
  var map$field_fixed64 = message.field_fixed64;
  if (map$field_fixed64 !== undefined) {
    for (var key in map$field_fixed64) {
      var nested = popByteBuffer();
      var value = map$field_fixed64[key];
      writeVarint32(nested, 9);
      writeInt64(nested, stringToLong(key));
      writeVarint32(nested, 17);
      writeDouble(nested, value);
      writeVarint32(bb, 34);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<sfixed64, bool> field_sfixed64 = 5;
  var map$field_sfixed64 = message.field_sfixed64;
  if (map$field_sfixed64 !== undefined) {
    for (var key in map$field_sfixed64) {
      var nested = popByteBuffer();
      var value = map$field_sfixed64[key];
      writeVarint32(nested, 9);
      writeInt64(nested, stringToLong(key));
      writeVarint32(nested, 16);
      writeByte(nested, value ? 1 : 0);
      writeVarint32(bb, 42);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }

  // optional map<bool, Nested> field_bool = 6;
  var map$field_bool = message.field_bool;
  if (map$field_bool !== undefined) {
    for (var key in map$field_bool) {
      var nested = popByteBuffer();
      var value = map$field_bool[key];
      writeVarint32(nested, 8);
      writeByte(nested, key === "true" ? 1 : 0);
      writeVarint32(nested, 18);
      var nestedValue = popByteBuffer();
      _encodeNested(value, nestedValue);
      writeVarint32(nested, nestedValue.limit);
      writeByteBuffer(nested, nestedValue);
      pushByteBuffer(nestedValue);
      writeVarint32(bb, 50);
      writeVarint32(bb, nested.offset);
      writeByteBuffer(bb, nested);
      pushByteBuffer(nested);
    }
  }
};

exports.decodeMapTestLongAndBool = function (binary) {
  return _decodeMapTestLongAndBool(wrapByteBuffer(binary));
}

function _decodeMapTestLongAndBool(bb) {
  var message = {};

  end_of_message: while (!isAtEnd(bb)) {
    var tag = readVarint32(bb);

    switch (tag >>> 3) {
      case 0:
        break end_of_message;

      // optional map<int64, string> field_int64 = 1;
      case 1: {
        var values = message.field_int64 || (message.field_int64 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch (tag >>> 3) {
            case 0:
              break end_of_entry;
            case 1: {
              key = readVarint64(bb, /* unsigned */ false);
              break;
            }
            case 2: {
              value = readString(bb, readVarint32(bb));
              break;
            }
            default:
              skipUnknownField(bb, tag & 7);
          }
        }
        if (key === undefined || value === undefined)
          throw new Error("Invalid data for map: field_int64");
        values[longToString(key)] = value;
        bb.limit = outerLimit;
        break;
      }

      // optional map<uint64, bytes> field_uint64 = 2;
      case 2: {
        var values = message.field_uint64 || (message.field_uint64 = {});
        var outerLimit = pushTemporaryLength(bb);
        var key;
        var value;
        end_of_entry: while (!isAtEnd(bb)) {
          var tag = readVarint32(bb);
          switch