angular-docs-cn/tools/build/protoc-gen-dart

#!/usr/bin/env dart
// Compiled https://github.com/dart-lang/dart-protoc-plugin/releases, v0.5.0
import "dart:convert";
import "dart:typed_data";
import "dart:math";
import "dart:math" as _A;
import "dart:collection";
import "dart:async";
import "dart:io";
import "dart:io" as _B;
class CryptoUtils {
  static String bytesToBase64_A(List<int> bytes, {bool urlSafe: false, bool addLineSeparator: false}) {
    return _CryptoUtils_A.bytesToBase64_B(bytes, urlSafe, addLineSeparator);
  }
}
const Base64Codec BASE64 = const Base64Codec();
const List<int> _decodeTable_A = const[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -2, -2, -2, 0, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2, 63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2];
const String _encodeTableUrlSafe_A = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
const String _encodeTable_A = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const int _LINE_LENGTH = 76;
const int _CR_A = 13;
const int _LF_A = 10;
const List<int> _PAD_BYTES = const[61];
const List<int> _ENCODED_PAD_BYTES = const[37, 51, 68];
const String _PAD = "=";
const String _ENCODED_PAD = "%3D";
class Base64Codec extends Codec<List<int>, String> {
  final bool _urlSafe;
  final bool _addLineSeparator;
  final bool _encodePaddingCharacter;
  const Base64Codec({bool urlSafe: false, bool addLineSeparator: false, bool encodePaddingCharacter: false}) : _urlSafe = urlSafe, _addLineSeparator = addLineSeparator, _encodePaddingCharacter = encodePaddingCharacter;
  String get name => "base64";
  String encode(List<int> bytes, {bool urlSafe, bool addLineSeparator, bool encodePaddingCharacter}) {
    if (urlSafe == null) urlSafe = _urlSafe;
    if (addLineSeparator == null) addLineSeparator = _addLineSeparator;
    if (encodePaddingCharacter == null) {
      encodePaddingCharacter = _encodePaddingCharacter;
    }
    return new Base64Encoder(urlSafe: urlSafe, addLineSeparator: addLineSeparator, encodePaddingCharacter: encodePaddingCharacter).convert(bytes);
  }
  Base64Encoder get encoder => new Base64Encoder(urlSafe: _urlSafe, addLineSeparator: _addLineSeparator, encodePaddingCharacter: _encodePaddingCharacter);
  Base64Decoder get decoder => new Base64Decoder();
}
class Base64Encoder extends Converter<List<int>, String> {
  final bool _urlSafe;
  final bool _addLineSeparator;
  final bool _encodePaddingCharacter;
  final List<int> _pad;
  const Base64Encoder({bool urlSafe: false, bool addLineSeparator: false, bool encodePaddingCharacter: false}) : _urlSafe = urlSafe, _addLineSeparator = addLineSeparator, _encodePaddingCharacter = encodePaddingCharacter, _pad = encodePaddingCharacter == true ? _ENCODED_PAD_BYTES : _PAD_BYTES;
  String convert(List<int> bytes, [int start_A = 0, int end_A]) {
    int bytes_length = bytes.length;
    RangeError.checkValidRange(start_A, end_A, bytes_length);
    if (end_A == null) end_A = bytes_length;
    int length_A = end_A - start_A;
    if (length_A == 0) {
      return "";
    }
    final String lookup_A = _urlSafe ? _encodeTableUrlSafe_A : _encodeTable_A;
    final int remainderLength = length_A.remainder(3);
    final int chunkLength = length_A - remainderLength;
    int baseOutputLength = ((length_A ~/ 3) * 4);
    int remainderOutputLength;
    if (_encodePaddingCharacter) {
      remainderOutputLength = ((remainderLength > 0) ? 6 : 0);
    } else {
      remainderOutputLength = ((remainderLength > 0) ? 4 : 0);
    }
    int outputLength = baseOutputLength + remainderOutputLength;
    if (_addLineSeparator) {
      outputLength += ((outputLength - 1) ~/ _LINE_LENGTH) << 1;
    }
    List<int> out = new List<int>(outputLength);
    int j = 0, i = start_A, c = 0;
    while (i < chunkLength) {
      int x_A = ((bytes[i++] << 16) & 0x00FFFFFF) | ((bytes[i++] << 8) & 0x00FFFFFF) | bytes[i++];
      out[j++] = lookup_A.codeUnitAt(x_A >> 18);
      out[j++] = lookup_A.codeUnitAt((x_A >> 12) & 0x3F);
      out[j++] = lookup_A.codeUnitAt((x_A >> 6) & 0x3F);
      out[j++] = lookup_A.codeUnitAt(x_A & 0x3F);
      if (_addLineSeparator && ++c == 19 && j < outputLength - 2) {
        out[j++] = _CR_A;
        out[j++] = _LF_A;
        c = 0;
      }
    }
    if (remainderLength == 1) {
      int x_A = bytes[i];
      out[j++] = lookup_A.codeUnitAt(x_A >> 2);
      out[j++] = lookup_A.codeUnitAt((x_A << 4) & 0x3F);
      out.setRange(j, j + _pad.length, _pad);
      out.setRange(j + _pad.length, j + 2 * _pad.length, _pad);
    } else if (remainderLength == 2) {
      int x_A = bytes[i];
      int y_A = bytes[i + 1];
      out[j++] = lookup_A.codeUnitAt(x_A >> 2);
      out[j++] = lookup_A.codeUnitAt(((x_A << 4) | (y_A >> 4)) & 0x3F);
      out[j++] = lookup_A.codeUnitAt((y_A << 2) & 0x3F);
      out.setRange(j, j + _pad.length, _pad);
    }
    return new String.fromCharCodes(out);
  }
  _Base64EncoderSink startChunkedConversion(Sink<String> sink_A) {
    StringConversionSink stringSink;
    if (sink_A is StringConversionSink) {
      stringSink = sink_A;
    } else {
      stringSink = new StringConversionSink.from(sink_A);
    }
    return new _Base64EncoderSink(stringSink, _urlSafe, _addLineSeparator);
  }
}
class _Base64EncoderSink extends ChunkedConversionSink<List<int>> {
  final Base64Encoder _encoder;
  final ChunkedConversionSink<String> _outSink;
  final List<int> _buffer_A = new List<int>();
  int _bufferCount = 0;
  _Base64EncoderSink(this._outSink, urlSafe, addLineSeparator) : _encoder = new Base64Encoder(urlSafe: urlSafe, addLineSeparator: addLineSeparator);
  void add(List<int> chunk) {
    var nextBufferCount = (chunk.length + _bufferCount) % 3;
    int decodableLength = _bufferCount + chunk.length - nextBufferCount;
    if (_bufferCount + chunk.length > _buffer_A.length) {
      _buffer_A.replaceRange(_bufferCount, _buffer_A.length, chunk.sublist(0, _buffer_A.length - _bufferCount));
      _buffer_A.addAll(chunk.sublist(_buffer_A.length - _bufferCount));
    } else {
      _buffer_A.replaceRange(_bufferCount, _bufferCount + chunk.length, chunk);
    }
    _outSink.add(_encoder.convert(_buffer_A, 0, decodableLength));
    _buffer_A.removeRange(0, decodableLength);
    _bufferCount = nextBufferCount;
  }
  void close() {
    if (_bufferCount > 0) {
      _outSink.add(_encoder.convert(_buffer_A.sublist(0, _bufferCount)));
    }
    _outSink.close();
  }
}
class Base64Decoder extends Converter<String, List<int>> {
  const Base64Decoder();
  List<int> convert(String input_A) {
    int length_A = input_A.length;
    if (length_A == 0) {
      return new Uint8List(0);
    }
    int normalLength = 0;
    int i = 0;
    while (i < length_A) {
      int codeUnit = input_A.codeUnitAt(i);
      int c = _decodeTable_A[codeUnit];
      if (c == -2) {
        if (codeUnit == _ENCODED_PAD_BYTES[0] && i < length_A - 2 && input_A.codeUnitAt(i + 1) == _ENCODED_PAD_BYTES[1] && input_A.codeUnitAt(i + 2) == _ENCODED_PAD_BYTES[2]) {
          normalLength++;
          i += 2;
        } else {
          throw new FormatException('Invalid character', input_A, i);
        }
      }
      if (c >= 0) normalLength++;
      i++;
    }
    if (normalLength % 4 != 0) {
      throw new FormatException('''Size of Base 64 characters in Input
          must be a multiple of 4''', input_A, normalLength);
    }
    int padLength = 0;
    i = length_A - 1;
    while (i >= 0) {
      int currentCodeUnit = input_A.codeUnitAt(i);
      if (currentCodeUnit == _ENCODED_PAD_BYTES[2] && i >= 2 && input_A.codeUnitAt(i - 1) == _ENCODED_PAD_BYTES[1] && input_A.codeUnitAt(i - 2) == _ENCODED_PAD_BYTES[0]) {
        padLength++;
        i -= 2;
      } else if (_decodeTable_A[currentCodeUnit] > 0) {
        break;
      } else if (currentCodeUnit == _PAD_BYTES[0]) {
        padLength++;
      }
      i--;
    }
    int outputLength = ((normalLength * 6) >> 3) - padLength;
    List<int> out = new Uint8List(outputLength);
    for (int i = 0, o = 0; o < outputLength;) {
      int x_A = 0;
      for (int j = 4; j > 0;) {
        int c = _decodeTable_A[input_A.codeUnitAt(i++)];
        if (c >= 0) {
          x_A = ((x_A << 6) & 0x00FFFFFF) | c;
          j--;
        }
      }
      out[o++] = x_A >> 16;
      if (o < outputLength) {
        out[o++] = (x_A >> 8) & 0xFF;
        if (o < outputLength) out[o++] = x_A & 0xFF;
      }
    }
    return out;
  }
  _Base64DecoderSink startChunkedConversion(Sink<List<int>> sink_A) {
    if (sink_A is! ByteConversionSink) {
      sink_A = new ByteConversionSink.from(sink_A);
    }
    return new _Base64DecoderSink(sink_A);
  }
}
class _Base64DecoderSink extends ChunkedConversionSink<String> {
  final Base64Decoder _decoder_A = new Base64Decoder();
  final ChunkedConversionSink<List<int>> _outSink;
  String _unconverted = "";
  _Base64DecoderSink(this._outSink);
  void add(String chunk) {
    if (chunk.isEmpty) return;
    if (_unconverted.isNotEmpty) {
      chunk = _unconverted + chunk;
    }
    chunk = chunk.replaceAll(_ENCODED_PAD, _PAD);
    int decodableLength = chunk.length;
    if (chunk.length > 3 && chunk.contains(_ENCODED_PAD[0], chunk.length - 2)) {
      decodableLength = chunk.lastIndexOf(_ENCODED_PAD[0]);
    }
    decodableLength -= decodableLength % 4;
    _unconverted = chunk.substring(decodableLength);
    if (decodableLength > 0) {
      _outSink.add(_decoder_A.convert(chunk.substring(0, decodableLength)));
    }
  }
  void close() {
    if (_unconverted.isNotEmpty) {
      _outSink.add(_decoder_A.convert(_unconverted));
    }
    _outSink.close();
  }
}
abstract class _CryptoUtils_A {
  static String bytesToBase64_B(List<int> bytes, [bool urlSafe = false, bool addLineSeparator = false]) {
    return BASE64.encode(bytes, urlSafe: urlSafe, addLineSeparator: addLineSeparator);
  }
}
class Dart_options {
  static final Extension defaultMixin = new Extension('FileOptions', 'defaultMixin', 96128839, PbFieldType.OS);
  static final Extension mixin = new Extension('MessageOptions', 'mixin', 96128839, PbFieldType.OS);
  static void registerAllExtensions(ExtensionRegistry registry) {
    registry.add(defaultMixin);
    registry.add(mixin);
  }
}
class Int32 implements IntX {
  static int _validateRadix(int radix) {
    if (2 <= radix && radix <= 36) return radix;
    throw new RangeError.range(radix, 2, 36, 'radix');
  }
}
class Int64 implements IntX {
  final int _l;
  final int _m;
  final int _h_A;
  static const int _BITS = 22;
  static const int _BITS01 = 44;
  static const int _BITS2 = 20;
  static const int _MASK = 4194303;
  static const int _MASK2 = 1048575;
  static const int _SIGN_BIT_MASK = 524288;
  static const Int64 ZERO_A = const Int64._bits(0, 0, 0);
  const Int64._bits(int this._l, int this._m, int this._h_A);
  factory Int64([int value_A = 0]) {
    int v0 = 0, v1 = 0, v2 = 0;
    bool negative = false;
    if (value_A < 0) {
      negative = true;
      value_A = -value_A - 1;
    }
    if (_haveBigInts) {
      v0 = _MASK & value_A;
      v1 = _MASK & (value_A >> _BITS);
      v2 = _MASK2 & (value_A >> _BITS01);
    } else {
      v2 = value_A ~/ 17592186044416;
      value_A -= v2 * 17592186044416;
      v1 = value_A ~/ 4194304;
      value_A -= v1 * 4194304;
      v0 = value_A;
    }
    if (negative) {
      v0 = ~v0;
      v1 = ~v1;
      v2 = ~v2;
    }
    return Int64._masked_A(v0, v1, v2);
  }
  factory Int64.fromBytes(List<int> bytes) {
    int top_A = bytes[7] & 0xff;
    top_A <<= 8;
    top_A |= bytes[6] & 0xff;
    top_A <<= 8;
    top_A |= bytes[5] & 0xff;
    top_A <<= 8;
    top_A |= bytes[4] & 0xff;
    int bottom_A = bytes[3] & 0xff;
    bottom_A <<= 8;
    bottom_A |= bytes[2] & 0xff;
    bottom_A <<= 8;
    bottom_A |= bytes[1] & 0xff;
    bottom_A <<= 8;
    bottom_A |= bytes[0] & 0xff;
    return new Int64.fromInts(top_A, bottom_A);
  }
  factory Int64.fromInts(int top_A, int bottom_A) {
    top_A &= 0xffffffff;
    bottom_A &= 0xffffffff;
    int d0 = _MASK & bottom_A;
    int d1 = ((0xfff & top_A) << 10) | (0x3ff & (bottom_A >> _BITS));
    int d2 = _MASK2 & (top_A >> 12);
    return new Int64._bits(d0, d1, d2);
  }
  static Int64 _promote(value_A) {
    if (value_A is Int64) {
      return value_A;
    } else if (value_A is int) {
      return new Int64(value_A);
    } else if (value_A is Int32) {
      return value_A.toInt64();
    }
    throw new ArgumentError.value(value_A);
  }
  Int64 operator+(other) {
    Int64 o = _promote(other);
    int sum0 = _l + o._l;
    int sum1 = _m + o._m + (sum0 >> _BITS);
    int sum2 = _h_A + o._h_A + (sum1 >> _BITS);
    return Int64._masked_A(sum0, sum1, sum2);
  }
  Int64 operator-(other) {
    Int64 o = _promote(other);
    return _sub(_l, _m, _h_A, o._l, o._m, o._h_A);
  }
  Int64 operator-() => _negate(_l, _m, _h_A);
  Int64 operator*(other) {
    Int64 o = _promote(other);
    int a0 = _l & 0x1fff;
    int a1 = (_l >> 13) | ((_m & 0xf) << 9);
    int a2 = (_m >> 4) & 0x1fff;
    int a3 = (_m >> 17) | ((_h_A & 0xff) << 5);
    int a4 = (_h_A & 0xfff00) >> 8;
    int b0 = o._l & 0x1fff;
    int b1 = (o._l >> 13) | ((o._m & 0xf) << 9);
    int b2 = (o._m >> 4) & 0x1fff;
    int b3 = (o._m >> 17) | ((o._h_A & 0xff) << 5);
    int b4 = (o._h_A & 0xfff00) >> 8;
    int p0 = a0 * b0;
    int p1 = a1 * b0;
    int p2 = a2 * b0;
    int p3 = a3 * b0;
    int p4 = a4 * b0;
    if (b1 != 0) {
      p1 += a0 * b1;
      p2 += a1 * b1;
      p3 += a2 * b1;
      p4 += a3 * b1;
    }
    if (b2 != 0) {
      p2 += a0 * b2;
      p3 += a1 * b2;
      p4 += a2 * b2;
    }
    if (b3 != 0) {
      p3 += a0 * b3;
      p4 += a1 * b3;
    }
    if (b4 != 0) {
      p4 += a0 * b4;
    }
    int c00 = p0 & 0x3fffff;
    int c01 = (p1 & 0x1ff) << 13;
    int c0 = c00 + c01;
    int c10 = p0 >> 22;
    int c11 = p1 >> 9;
    int c12 = (p2 & 0x3ffff) << 4;
    int c13 = (p3 & 0x1f) << 17;
    int c1 = c10 + c11 + c12 + c13;
    int c22 = p2 >> 18;
    int c23 = p3 >> 5;
    int c24 = (p4 & 0xfff) << 8;
    int c2 = c22 + c23 + c24;
    c1 += c0 >> _BITS;
    c2 += c1 >> _BITS;
    return Int64._masked_A(c0, c1, c2);
  }
  Int64 operator%(other) => _divide(this, other, _RETURN_MOD);
  Int64 operator~/(other) => _divide(this, other, _RETURN_DIV);
  Int64 remainder(other) => _divide(this, other, _RETURN_REM);
  Int64 operator&(other) {
    Int64 o = _promote(other);
    int a0 = _l & o._l;
    int a1 = _m & o._m;
    int a2 = _h_A & o._h_A;
    return new Int64._bits(a0, a1, a2);
  }
  Int64 operator|(other) {
    Int64 o = _promote(other);
    int a0 = _l | o._l;
    int a1 = _m | o._m;
    int a2 = _h_A | o._h_A;
    return new Int64._bits(a0, a1, a2);
  }
  Int64 operator^(other) {
    Int64 o = _promote(other);
    int a0 = _l ^ o._l;
    int a1 = _m ^ o._m;
    int a2 = _h_A ^ o._h_A;
    return Int64._masked_A(a0, a1, a2);
  }
  Int64 operator~() {
    return Int64._masked_A(~_l, ~_m, ~_h_A);
  }
  Int64 operator<<(int n) {
    if (n < 0) {
      throw new ArgumentError.value(n);
    }
    n &= 63;
    int res0, res1, res2;
    if (n < _BITS) {
      res0 = _l << n;
      res1 = (_m << n) | (_l >> (_BITS - n));
      res2 = (_h_A << n) | (_m >> (_BITS - n));
    } else if (n < _BITS01) {
      res0 = 0;
      res1 = _l << (n - _BITS);
      res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
    } else {
      res0 = 0;
      res1 = 0;
      res2 = _l << (n - _BITS01);
    }
    return Int64._masked_A(res0, res1, res2);
  }
  Int64 operator>>(int n) {
    if (n < 0) {
      throw new ArgumentError.value(n);
    }
    n &= 63;
    int res0, res1, res2;
    int a2 = _h_A;
    bool negative = (a2 & _SIGN_BIT_MASK) != 0;
    if (negative && _MASK > _MASK2) {
      a2 += (_MASK - _MASK2);
    }
    if (n < _BITS) {
      res2 = _shiftRight(a2, n);
      if (negative) {
        res2 |= _MASK2 & ~(_MASK2 >> n);
      }
      res1 = _shiftRight(_m, n) | (a2 << (_BITS - n));
      res0 = _shiftRight(_l, n) | (_m << (_BITS - n));
    } else if (n < _BITS01) {
      res2 = negative ? _MASK2 : 0;
      res1 = _shiftRight(a2, n - _BITS);
      if (negative) {
        res1 |= _MASK & ~(_MASK >> (n - _BITS));
      }
      res0 = _shiftRight(_m, n - _BITS) | (a2 << (_BITS01 - n));
    } else {
      res2 = negative ? _MASK2 : 0;
      res1 = negative ? _MASK : 0;
      res0 = _shiftRight(a2, n - _BITS01);
      if (negative) {
        res0 |= _MASK & ~(_MASK >> (n - _BITS01));
      }
    }
    return Int64._masked_A(res0, res1, res2);
  }
  bool operator==(other) {
    Int64 o;
    if (other is Int64) {
      o = other;
    } else if (other is int) {
      if (_h_A == 0 && _m == 0) return _l == other;
      if ((_MASK & other) == other) return false;
      o = new Int64(other);
    } else if (other is Int32) {
      o = other.toInt64();
    }
    if (o != null) {
      return _l == o._l && _m == o._m && _h_A == o._h_A;
    }
    return false;
  }
  int compareTo(IntX other) => _compareTo(other);
  int _compareTo(other) {
    Int64 o = _promote(other);
    int signa = _h_A >> (_BITS2 - 1);
    int signb = o._h_A >> (_BITS2 - 1);
    if (signa != signb) {
      return signa == 0 ? 1 : -1;
    }
    if (_h_A > o._h_A) {
      return 1;
    } else if (_h_A < o._h_A) {
      return -1;
    }
    if (_m > o._m) {
      return 1;
    } else if (_m < o._m) {
      return -1;
    }
    if (_l > o._l) {
      return 1;
    } else if (_l < o._l) {
      return -1;
    }
    return 0;
  }
  bool operator<(other) => _compareTo(other) < 0;
  bool operator<=(other) => _compareTo(other) <= 0;
  bool operator>(other) => this._compareTo(other) > 0;
  bool operator>=(other) => _compareTo(other) >= 0;
  bool get isNegative => (_h_A & _SIGN_BIT_MASK) != 0;
  bool get isZero => _h_A == 0 && _m == 0 && _l == 0;
  int get hashCode {
    int bottom_A = ((_m & 0x3ff) << _BITS) | _l;
    int top_A = (_h_A << 12) | ((_m >> 10) & 0xfff);
    return bottom_A ^ top_A;
  }
  Int64 abs() {
    return this.isNegative ? -this : this;
  }
  List<int> toBytes() {
    List<int> result_A = new List<int>(8);
    result_A[0] = _l & 0xff;
    result_A[1] = (_l >> 8) & 0xff;
    result_A[2] = ((_m << 6) & 0xfc) | ((_l >> 16) & 0x3f);
    result_A[3] = (_m >> 2) & 0xff;
    result_A[4] = (_m >> 10) & 0xff;
    result_A[5] = ((_h_A << 4) & 0xf0) | ((_m >> 18) & 0xf);
    result_A[6] = (_h_A >> 4) & 0xff;
    result_A[7] = (_h_A >> 12) & 0xff;
    return result_A;
  }
  int toInt() {
    int l = _l;
    int m = _m;
    int h = _h_A;
    bool negative = false;
    if ((_h_A & _SIGN_BIT_MASK) != 0) {
      l = _MASK & ~_l;
      m = _MASK & ~_m;
      h = _MASK2 & ~_h_A;
      negative = true;
    }
    if (_haveBigInts) {
      int result_A = (h << _BITS01) | (m << _BITS) | l;
      return negative ? -result_A - 1 : result_A;
    } else {
      if (negative) {
        return -((l + 1) + (m * 4194304) + (h * 17592186044416));
      } else {
        return (l + (m * 4194304)) + (h * 17592186044416);
      }
    }
  }
  Int64 toInt64() => this;
  String toString() => _toRadixString(10);
  String toRadixString(int radix) {
    return _toRadixString(Int32._validateRadix(radix));
  }
  String _toRadixString(int radix) {
    int d0 = _l;
    int d1 = _m;
    int d2 = _h_A;
    if (d0 == 0 && d1 == 0 && d2 == 0) return '0';
    String sign_A = '';
    if ((d2 & _SIGN_BIT_MASK) != 0) {
      sign_A = '-';
      d0 = 0 - d0;
      int borrow = (d0 >> _BITS) & 1;
      d0 &= _MASK;
      d1 = 0 - d1 - borrow;
      borrow = (d1 >> _BITS) & 1;
      d1 &= _MASK;
      d2 = 0 - d2 - borrow;
      d2 &= _MASK2;
    }
    int d4 = (d2 << 4) | (d1 >> 18);
    int d3 = (d1 >> 8) & 0x3ff;
    d2 = ((d1 << 2) | (d0 >> 20)) & 0x3ff;
    d1 = (d0 >> 10) & 0x3ff;
    d0 = d0 & 0x3ff;
    int fatRadix = _fatRadixTable[radix];
    String chunk1 = "", chunk2 = "", chunk3 = "";
    while (!(d4 == 0 && d3 == 0)) {
      int q = d4 ~/ fatRadix;
      int r = d4 - q * fatRadix;
      d4 = q;
      d3 += r << 10;
      q = d3 ~/ fatRadix;
      r = d3 - q * fatRadix;
      d3 = q;
      d2 += r << 10;
      q = d2 ~/ fatRadix;
      r = d2 - q * fatRadix;
      d2 = q;
      d1 += r << 10;
      q = d1 ~/ fatRadix;
      r = d1 - q * fatRadix;
      d1 = q;
      d0 += r << 10;
      q = d0 ~/ fatRadix;
      r = d0 - q * fatRadix;
      d0 = q;
      assert(chunk3 == "");
      chunk3 = chunk2;
      chunk2 = chunk1;
      chunk1 = (fatRadix + r).toRadixString(radix).substring(1);
    }
    int residue = (d2 << 20) + (d1 << 10) + d0;
    String leadingDigits = residue == 0 ? '' : residue.toRadixString(radix);
    return '${sign_A}${leadingDigits}${chunk1}${chunk2}${chunk3}';
  }
  static const _fatRadixTable = const<int>[0, 0, 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2, 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3, 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4, 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5, 6 * 6 * 6 * 6 * 6 * 6 * 6, 7 * 7 * 7 * 7 * 7 * 7 * 7, 8 * 8 * 8 * 8 * 8 * 8, 9 * 9 * 9 * 9 * 9 * 9, 10 * 10 * 10 * 10 * 10 * 10, 11 * 11 * 11 * 11 * 11, 12 * 12 * 12 * 12 * 12, 13 * 13 * 13 * 13 * 13, 14 * 14 * 14 * 14 * 14, 15 * 15 * 15 * 15 * 15, 16 * 16 * 16 * 16 * 16, 17 * 17 * 17 * 17, 18 * 18 * 18 * 18, 19 * 19 * 19 * 19, 20 * 20 * 20 * 20, 21 * 21 * 21 * 21, 22 * 22 * 22 * 22, 23 * 23 * 23 * 23, 24 * 24 * 24 * 24, 25 * 25 * 25 * 25, 26 * 26 * 26 * 26, 27 * 27 * 27 * 27, 28 * 28 * 28 * 28, 29 * 29 * 29 * 29, 30 * 30 * 30 * 30, 31 * 31 * 31 * 31, 32 * 32 * 32 * 32, 33 * 33 * 33, 34 * 34 * 34, 35 * 35 * 35, 36 * 36 * 36];
  static Int64 _masked_A(int a0, int a1, int a2) => new Int64._bits(_MASK & a0, _MASK & a1, _MASK2 & a2);
  static Int64 _sub(int a0, int a1, int a2, int b0, int b1, int b2) {
    int diff0 = a0 - b0;
    int diff1 = a1 - b1 - ((diff0 >> _BITS) & 1);
    int diff2 = a2 - b2 - ((diff1 >> _BITS) & 1);
    return _masked_A(diff0, diff1, diff2);
  }
  static Int64 _negate(int b0, int b1, int b2) {
    return _sub(0, 0, 0, b0, b1, b2);
  }
  static bool _haveBigIntsCached = null;
  static bool get _haveBigInts {
    if (_haveBigIntsCached == null) {
      var x_A = 9007199254740992;
      if (2 + 2 != 4) {
        x_A = 0;
      }
      var y_A = x_A + 1;
      var same = y_A == x_A;
      _haveBigIntsCached = !same;
    }
    return _haveBigIntsCached;
  }
  static int _shiftRight(int x_A, int n) {
    if (x_A >= 0) {
      return x_A >> n;
    } else {
      int shifted = x_A >> n;
      if (shifted >= 0x80000000) {
        shifted -= 4294967296;
      }
      return shifted;
    }
  }
  static Int64 _divide(Int64 a, other, int what) {
    Int64 b = _promote(other);
    if (b.isZero) {
      throw new IntegerDivisionByZeroException();
    }
    if (a.isZero) return ZERO_A;
    bool aNeg = a.isNegative;
    bool bNeg = b.isNegative;
    a = a.abs();
    b = b.abs();
    int a0 = a._l;
    int a1 = a._m;
    int a2 = a._h_A;
    int b0 = b._l;
    int b1 = b._m;
    int b2 = b._h_A;
    return _divideHelper(a0, a1, a2, aNeg, b0, b1, b2, bNeg, what);
  }
  static const _RETURN_DIV = 1;
  static const _RETURN_REM = 2;
  static const _RETURN_MOD = 3;
  static _divideHelper(int a0, int a1, int a2, bool aNeg, int b0, int b1, int b2, bool bNeg, int what) {
    int q0 = 0, q1 = 0, q2 = 0;
    int r0 = 0, r1 = 0, r2 = 0;
    if (b2 == 0 && b1 == 0 && b0 < (1 << (30 - _BITS))) {
      q2 = a2 ~/ b0;
      int carry = a2 - q2 * b0;
      int d1 = a1 + (carry << _BITS);
      q1 = d1 ~/ b0;
      carry = d1 - q1 * b0;
      int d0 = a0 + (carry << _BITS);
      q0 = d0 ~/ b0;
      r0 = d0 - q0 * b0;
    } else {
      const double K2 = 17592186044416.0;
      const double K1 = 4194304.0;
      double ad = a0 + K1 * a1 + K2 * a2;
      double bd = b0 + K1 * b1 + K2 * b2;
      double qd = (ad / bd).floorToDouble();
      double q2d = (qd / K2).floorToDouble();
      qd = qd - K2 * q2d;
      double q1d = (qd / K1).floorToDouble();
      double q0d = qd - K1 * q1d;
      q2 = q2d.toInt();
      q1 = q1d.toInt();
      q0 = q0d.toInt();
      assert(q0 + K1 * q1 + K2 * q2 == (ad / bd).floorToDouble());
      assert(q2 == 0 || b2 == 0);
      double p0d = q0d * b0;
      double p0carry = (p0d / K1).floorToDouble();
      p0d = p0d - p0carry * K1;
      double p1d = q1d * b0 + q0d * b1 + p0carry;
      double p1carry = (p1d / K1).floorToDouble();
      p1d = p1d - p1carry * K1;
      double p2d = q2d * b0 + q1d * b1 + q0d * b2 + p1carry;
      assert(p2d <= _MASK2);
      int diff0 = a0 - p0d.toInt();
      int diff1 = a1 - p1d.toInt() - ((diff0 >> _BITS) & 1);
      int diff2 = a2 - p2d.toInt() - ((diff1 >> _BITS) & 1);
      r0 = _MASK & diff0;
      r1 = _MASK & diff1;
      r2 = _MASK2 & diff2;
      while (r2 >= _SIGN_BIT_MASK || r2 > b2 || (r2 == b2 && (r1 > b1 || (r1 == b1 && r0 >= b0)))) {
        int m = (r2 & _SIGN_BIT_MASK) == 0 ? 1 : -1;
        int d0 = r0 - m * b0;
        int d1 = r1 - m * (b1 + ((d0 >> _BITS) & 1));
        int d2 = r2 - m * (b2 + ((d1 >> _BITS) & 1));
        r0 = _MASK & d0;
        r1 = _MASK & d1;
        r2 = _MASK2 & d2;
        d0 = q0 + m;
        d1 = q1 + m * ((d0 >> _BITS) & 1);
        d2 = q2 + m * ((d1 >> _BITS) & 1);
        q0 = _MASK & d0;
        q1 = _MASK & d1;
        q2 = _MASK2 & d2;
      }
    }
    assert(Int64.ZERO_A <= new Int64._bits(r0, r1, r2));
    assert(r2 < b2 || new Int64._bits(r0, r1, r2) < new Int64._bits(b0, b1, b2));
    assert(what == _RETURN_DIV || what == _RETURN_MOD || what == _RETURN_REM);
    if (what == _RETURN_DIV) {
      if (aNeg != bNeg) return _negate(q0, q1, q2);
      return Int64._masked_A(q0, q1, q2);
    }
    if (!aNeg) {
      return Int64._masked_A(r0, r1, r2);
    }
    if (what == _RETURN_MOD) {
      if (r0 == 0 && r1 == 0 && r2 == 0) {
        return ZERO_A;
      } else {
        return _sub(b0, b1, b2, r0, r1, r2);
      }
    } else {
      return _negate(r0, r1, r2);
    }
  }
}
abstract class IntX implements Comparable<IntX> {
  IntX operator+(other);
  IntX operator-(other);
  IntX operator-();
  IntX operator*(other);
  IntX operator%(other);
  IntX operator~/(other);
  IntX remainder(other);
  IntX operator&(other);
  IntX operator|(other);
  IntX operator^(other);
  IntX operator~();
  IntX operator<<(int shiftAmount);
  IntX operator>>(int shiftAmount);
  bool operator==(other);
  bool operator<(other);
  bool operator<=(other);
  bool operator>(other);
  bool operator>=(other);
  bool get isNegative;
  bool get isZero;
  int get hashCode;
  IntX abs();
  List<int> toBytes();
  int toInt();
  Int64 toInt64();
  String toString();
  String toRadixString(int radix);
}
final Context url = new Context(style: Style.url_A);
final Context context_A = createInternal();
String get current_A {
  var uri_A = Uri.base;
  if (Style.platform == Style.url_A) {
    return uri_A.resolve('.').toString();
  } else {
    var path_A = uri_A.toFilePath();
    int lastIndex = path_A.length - 1;
    assert(path_A[lastIndex] == '/' || path_A[lastIndex] == '\\');
    return path_A.substring(0, lastIndex);
  }
}
String withoutExtension(String path_A) => context_A.withoutExtension_A(path_A);
const SLASH_A = 0x2f;
const COLON_A = 0x3a;
const UPPER_A = 0x41;
const UPPER_Z = 0x5a;
const LOWER_A = 0x61;
const LOWER_Z = 0x7a;
const BACKSLASH_A = 0x5c;
Context createInternal() => new Context._internal_A();
class Context {
  factory Context({Style style, String current}) {
    if (current == null) {
      if (style == null) {
        current = current_A;
      } else {
        current = ".";
      }
    }
    if (style == null) {
      style = Style.platform;
    } else if (style is! InternalStyle) {
      throw new ArgumentError("Only styles defined by the path package are " "allowed.");
    }
    return new Context.__A(style as InternalStyle, current);
  }
  Context._internal_A() : style = Style.platform as InternalStyle, _current_A = null;
  Context.__A(this.style, this._current_A);
  final InternalStyle style;
  final String _current_A;
  String get current => _current_A != null ? _current_A : current_A;
  String get separator => style.separator;
  String absolute(String part1, [String part2, String part3, String part4, String part5, String part6, String part7]) {
    return join(current, part1, part2, part3, part4, part5, part6, part7);
  }
  String basenameWithoutExtension(String path_A) => _parse_A(path_A).basenameWithoutExtension;
  String dirname(String path_A) {
    var parsed = _parse_A(path_A);
    parsed.removeTrailingSeparators();
    if (parsed.parts.isEmpty) return parsed.root == null ? '.' : parsed.root;
    if (parsed.parts.length == 1) {
      return parsed.root == null ? '.' : parsed.root;
    }
    parsed.parts.removeLast();
    parsed.separators.removeLast();
    parsed.removeTrailingSeparators();
    return parsed.toString();
  }
  String extension(String path_A) => _parse_A(path_A).extension;
  String rootPrefix(String path_A) => path_A.substring(0, style.rootLength(path_A));
  bool isAbsolute(String path_A) => style.rootLength(path_A) > 0;
  bool isRelative(String path_A) => !this.isAbsolute(path_A);
  bool isRootRelative(String path_A) => style.isRootRelative(path_A);
  String join(String part1, [String part2, String part3, String part4, String part5, String part6, String part7, String part8]) {
    var parts = <String>[part1, part2, part3, part4, part5, part6, part7, part8];
    _validateArgList("join", parts);
    return joinAll(parts.where((part_A) => part_A != null));
  }
  String joinAll(Iterable<String> parts) {
    var buffer_A = new StringBuffer();
    var needsSeparator = false;
    var isAbsoluteAndNotRootRelative = false;
    for (var part_A in parts.where((part_A) => part_A != '')) {
      if (this.isRootRelative(part_A) && isAbsoluteAndNotRootRelative) {
        var parsed = _parse_A(part_A);
        parsed.root = this.rootPrefix(buffer_A.toString());
        if (style.needsSeparator(parsed.root)) {
          parsed.separators[0] = style.separator;
        }
        buffer_A.clear();
        buffer_A.write(parsed.toString());
      } else if (this.isAbsolute(part_A)) {
        isAbsoluteAndNotRootRelative = !this.isRootRelative(part_A);
        buffer_A.clear();
        buffer_A.write(part_A);
      } else {
        if (part_A.length > 0 && style.containsSeparator(part_A[0])) {} else if (needsSeparator) {
          buffer_A.write(separator);
        }
        buffer_A.write(part_A);
      }
      needsSeparator = style.needsSeparator(part_A);
    }
    return buffer_A.toString();
  }
  List<String> split(String path_A) {
    var parsed = _parse_A(path_A);
    parsed.parts = parsed.parts.where((part_A) => !part_A.isEmpty).toList();
    if (parsed.root != null) parsed.parts.insert(0, parsed.root);
    return parsed.parts;
  }
  String normalize(String path_A) {
    var parsed = _parse_A(path_A);
    parsed.normalize();
    return parsed.toString();
  }
  String relative(String path_A, {String from}) {
    if (from == null) {
      from = current;
    } else if (this.isRelative(from) || this.isRootRelative(from)) {
      from = this.join(current, from);
    }
    if (this.isRelative(from) && this.isAbsolute(path_A)) {
      return this.normalize(path_A);
    }
    if (this.isRelative(path_A) || this.isRootRelative(path_A)) {
      path_A = this.absolute(path_A);
    }
    if (this.isRelative(path_A) && this.isAbsolute(from)) {
      throw new PathException('Unable to find a path to "${path_A}" from "${from}".');
    }
    var fromParsed = _parse_A(from)
        ..normalize();
    var pathParsed = _parse_A(path_A)
        ..normalize();
    if (fromParsed.parts.length > 0 && fromParsed.parts[0] == '.') {
      return pathParsed.toString();
    }
    if (fromParsed.root != pathParsed.root && ((fromParsed.root == null || pathParsed.root == null) || fromParsed.root.toLowerCase().replaceAll('/', '\\') != pathParsed.root.toLowerCase().replaceAll('/', '\\'))) {
      return pathParsed.toString();
    }
    while (fromParsed.parts.length > 0 && pathParsed.parts.length > 0 && fromParsed.parts[0] == pathParsed.parts[0]) {
      fromParsed.parts.removeAt(0);
      fromParsed.separators.removeAt(1);
      pathParsed.parts.removeAt(0);
      pathParsed.separators.removeAt(1);
    }
    if (fromParsed.parts.length > 0 && fromParsed.parts[0] == '..') {
      throw new PathException('Unable to find a path to "${path_A}" from "${from}".');
    }
    pathParsed.parts.insertAll(0, new List.filled(fromParsed.parts.length, '..'));
    pathParsed.separators[0] = '';
    pathParsed.separators.insertAll(1, new List.filled(fromParsed.parts.length, style.separator));
    if (pathParsed.parts.length == 0) return '.';
    if (pathParsed.parts.length > 1 && pathParsed.parts.last == '.') {
      pathParsed.parts.removeLast();
      pathParsed.separators
          ..removeLast()
          ..removeLast()
          ..add('');
    }
    pathParsed.root = '';
    pathParsed.removeTrailingSeparators();
    return pathParsed.toString();
  }
  String withoutExtension_A(String path_A) {
    var parsed = _parse_A(path_A);
    for (var i = parsed.parts.length - 1; i >= 0; i--) {
      if (!parsed.parts[i].isEmpty) {
        parsed.parts[i] = parsed.basenameWithoutExtension;
        break;
      }
    }
    return parsed.toString();
  }
  String fromUri_A(uri_A) {
    if (uri_A is String) uri_A = Uri.parse(uri_A);
    return style.pathFromUri(uri_A);
  }
  Uri toUri(String path_A) {
    if (isRelative(path_A)) {
      return style.relativePathToUri(path_A);
    } else {
      return style.absolutePathToUri(join(current, path_A));
    }
  }
  ParsedPath _parse_A(String path_A) => new ParsedPath.parse_A(path_A, style);
}
_validateArgList(String method_A, List<String> args) {
  for (var i = 1; i < args.length; i++) {
    if (args[i] == null || args[i - 1] != null) continue;
    var numArgs;
    for (numArgs = args.length; numArgs >= 1; numArgs--) {
      if (args[numArgs - 1] != null) break;
    }
    var message_A = new StringBuffer();
    message_A.write("${method_A}(");
    message_A.write(args.take(numArgs).map((arg) => arg == null ? "null" : '"${arg}"').join(", "));
    message_A.write("): part ${i - 1} was null, but part ${i} was not.");
    throw new ArgumentError(message_A.toString());
  }
}
abstract class InternalStyle extends Style {
  String get separator;
  bool containsSeparator(String path_A);
  bool isSeparator(int codeUnit);
  bool needsSeparator(String path_A);
  int rootLength(String path_A);
  String getRoot(String path_A) {
    var length_A = rootLength(path_A);
    if (length_A > 0) return path_A.substring(0, length_A);
    return isRootRelative(path_A) ? path_A[0] : null;
  }
  bool isRootRelative(String path_A);
  String pathFromUri(Uri uri_A);
  Uri relativePathToUri(String path_A) {
    var segments = context.split(path_A);
    if (isSeparator(path_A.codeUnitAt(path_A.length - 1))) segments.add('');
    return new Uri(pathSegments: segments);
  }
  Uri absolutePathToUri(String path_A);
}
class ParsedPath {
  InternalStyle style;
  String root;
  bool isRootRelative;
  List<String> parts;
  List<String> separators;
  String get extension => _splitExtension()[1];
  bool get isAbsolute => root != null;
  factory ParsedPath.parse_A(String path_A, InternalStyle style_A) {
    var root_A = style_A.getRoot(path_A);
    var isRootRelative_A = style_A.isRootRelative(path_A);
    if (root_A != null) path_A = path_A.substring(root_A.length);
    var parts_A = <String>[];
    var separators_A = <String>[];
    var start_A = 0;
    if (path_A.isNotEmpty && style_A.isSeparator(path_A.codeUnitAt(0))) {
      separators_A.add(path_A[0]);
      start_A = 1;
    } else {
      separators_A.add('');
    }
    for (var i = start_A; i < path_A.length; i++) {
      if (style_A.isSeparator(path_A.codeUnitAt(i))) {
        parts_A.add(path_A.substring(start_A, i));
        separators_A.add(path_A[i]);
        start_A = i + 1;
      }
    }
    if (start_A < path_A.length) {
      parts_A.add(path_A.substring(start_A));
      separators_A.add('');
    }
    return new ParsedPath.__B(style_A, root_A, isRootRelative_A, parts_A, separators_A);
  }
  ParsedPath.__B(this.style, this.root, this.isRootRelative, this.parts, this.separators);
  String get basenameWithoutExtension => _splitExtension()[0];
  bool get hasTrailingSeparator => !parts.isEmpty && (parts.last == '' || separators.last != '');
  void removeTrailingSeparators() {
    while (!parts.isEmpty && parts.last == '') {
      parts.removeLast();
      separators.removeLast();
    }
    if (separators.length > 0) separators[separators.length - 1] = '';
  }
  void normalize() {
    var leadingDoubles = 0;
    var newParts = <String>[];
    for (var part_A in parts) {
      if (part_A == '.' || part_A == '') {} else if (part_A == '..') {
        if (newParts.length > 0) {
          newParts.removeLast();
        } else {
          leadingDoubles++;
        }
      } else {
        newParts.add(part_A);
      }
    }
    if (!isAbsolute) {
      newParts.insertAll(0, new List.filled(leadingDoubles, '..'));
    }
    if (newParts.length == 0 && !isAbsolute) {
      newParts.add('.');
    }
    var newSeparators = new List<String>.generate(newParts.length, (__H) => style.separator, growable: true);
    newSeparators.insert(0, isAbsolute && newParts.length > 0 && style.needsSeparator(root) ? style.separator : '');
    parts = newParts;
    separators = newSeparators;
    if (root != null && style == Style.windows) {
      root = root.replaceAll('/', '\\');
    }
    removeTrailingSeparators();
  }
  String toString() {
    var builder_A = new StringBuffer();
    if (root != null) builder_A.write(root);
    for (var i = 0; i < parts.length; i++) {
      builder_A.write(separators[i]);
      builder_A.write(parts[i]);
    }
    builder_A.write(separators.last);
    return builder_A.toString();
  }
  List<String> _splitExtension() {
    var file_A = parts.lastWhere((p) => p != '', orElse: () => null);
    if (file_A == null) return ['', ''];
    if (file_A == '..') return ['..', ''];
    var lastDot = file_A.lastIndexOf('.');
    if (lastDot <= 0) return [file_A, ''];
    return [file_A.substring(0, lastDot), file_A.substring(lastDot)];
  }
  ParsedPath clone() => new ParsedPath.__B(style, root, isRootRelative, new List.from(parts), new List.from(separators));
}
class PathException implements Exception {
  String message;
  PathException(this.message);
  String toString() => "PathException: ${message}";
}
abstract class Style {
  static final Style posix = new PosixStyle();
  static final Style windows = new WindowsStyle();
  static final Style url_A = new UrlStyle();
  static final Style platform = _getPlatformStyle();
  static Style _getPlatformStyle() {
    if (Uri.base.scheme != 'file') return Style.url_A;
    if (!Uri.base.path.endsWith('/')) return Style.url_A;
    if (new Uri(path: 'a/b').toFilePath() == 'a\\b') return Style.windows;
    return Style.posix;
  }
  String get name;
  Context get context => new Context(style: this);
  String get separator;
  String getRoot(String path_A);
  String pathFromUri(Uri uri_A);
  Uri relativePathToUri(String path_A);
  Uri absolutePathToUri(String path_A);
  String toString() => name;
}
class PosixStyle extends InternalStyle {
  PosixStyle();
  final name = 'posix';
  final separator = '/';
  final separators = const['/'];
  final separatorPattern = new RegExp(r'/');
  final needsSeparatorPattern = new RegExp(r'[^/]$');
  final rootPattern = new RegExp(r'^/');
  final relativeRootPattern = null;
  bool containsSeparator(String path_A) => path_A.contains('/');
  bool isSeparator(int codeUnit) => codeUnit == SLASH_A;
  bool needsSeparator(String path_A) => path_A.isNotEmpty && !isSeparator(path_A.codeUnitAt(path_A.length - 1));
  int rootLength(String path_A) {
    if (path_A.isNotEmpty && isSeparator(path_A.codeUnitAt(0))) return 1;
    return 0;
  }
  bool isRootRelative(String path_A) => false;
  String pathFromUri(Uri uri_A) {
    if (uri_A.scheme == '' || uri_A.scheme == 'file') {
      return Uri.decodeComponent(uri_A.path);
    }
    throw new ArgumentError("Uri ${uri_A} must have scheme 'file:'.");
  }
  Uri absolutePathToUri(String path_A) {
    var parsed = new ParsedPath.parse_A(path_A, this);
    if (parsed.parts.isEmpty) {
      parsed.parts.addAll(["", ""]);
    } else if (parsed.hasTrailingSeparator) {
      parsed.parts.add("");
    }
    return new Uri(scheme: 'file', pathSegments: parsed.parts);
  }
}
class UrlStyle extends InternalStyle {
  UrlStyle();
  final name = 'url';
  final separator = '/';
  final separators = const['/'];
  final separatorPattern = new RegExp(r'/');
  final needsSeparatorPattern = new RegExp(r"(^[a-zA-Z][-+.a-zA-Z\d]*://|[^/])$");
  final rootPattern = new RegExp(r"[a-zA-Z][-+.a-zA-Z\d]*://[^/]*");
  final relativeRootPattern = new RegExp(r"^/");
  bool containsSeparator(String path_A) => path_A.contains('/');
  bool isSeparator(int codeUnit) => codeUnit == SLASH_A;
  bool needsSeparator(String path_A) {
    if (path_A.isEmpty) return false;
    if (!isSeparator(path_A.codeUnitAt(path_A.length - 1))) return true;
    return path_A.endsWith("://") && rootLength(path_A) == path_A.length;
  }
  int rootLength(String path_A) {
    if (path_A.isEmpty) return 0;
    if (isSeparator(path_A.codeUnitAt(0))) return 1;
    var index_A = path_A.indexOf("/");
    if (index_A > 0 && path_A.startsWith('://', index_A - 1)) {
      index_A = path_A.indexOf('/', index_A + 2);
      if (index_A > 0) return index_A;
      return path_A.length;
    }
    return 0;
  }
  bool isRootRelative(String path_A) => path_A.isNotEmpty && isSeparator(path_A.codeUnitAt(0));
  String pathFromUri(Uri uri_A) => uri_A.toString();
  Uri relativePathToUri(String path_A) => Uri.parse(path_A);
  Uri absolutePathToUri(String path_A) => Uri.parse(path_A);
}
class WindowsStyle extends InternalStyle {
  WindowsStyle();
  final name = 'windows';
  final separator = '\\';
  final separators = const['/', '\\'];
  final separatorPattern = new RegExp(r'[/\\]');
  final needsSeparatorPattern = new RegExp(r'[^/\\]$');
  final rootPattern = new RegExp(r'^(\\\\[^\\]+\\[^\\/]+|[a-zA-Z]:[/\\])');
  final relativeRootPattern = new RegExp(r"^[/\\](?![/\\])");
  bool containsSeparator(String path_A) => path_A.contains('/');
  bool isSeparator(int codeUnit) => codeUnit == SLASH_A || codeUnit == BACKSLASH_A;
  bool needsSeparator(String path_A) {
    if (path_A.isEmpty) return false;
    return !isSeparator(path_A.codeUnitAt(path_A.length - 1));
  }
  int rootLength(String path_A) {
    if (path_A.isEmpty) return 0;
    if (path_A.codeUnitAt(0) == SLASH_A) return 1;
    if (path_A.codeUnitAt(0) == BACKSLASH_A) {
      if (path_A.length < 2 || path_A.codeUnitAt(1) != BACKSLASH_A) return 1;
      var index_A = path_A.indexOf('\\', 2);
      if (index_A > 0) {
        index_A = path_A.indexOf('\\', index_A + 1);
        if (index_A > 0) return index_A;
      }
      return path_A.length;
    }
    if (path_A.length < 3) return 0;
    if (!isAlphabetic(path_A.codeUnitAt(0))) return 0;
    if (path_A.codeUnitAt(1) != COLON_A) return 0;
    if (!isSeparator(path_A.codeUnitAt(2))) return 0;
    return 3;
  }
  bool isRootRelative(String path_A) => rootLength(path_A) == 1;
  String pathFromUri(Uri uri_A) {
    if (uri_A.scheme != '' && uri_A.scheme != 'file') {
      throw new ArgumentError("Uri ${uri_A} must have scheme 'file:'.");
    }
    var path_A = uri_A.path;
    if (uri_A.host == '') {
      if (path_A.startsWith('/')) path_A = path_A.replaceFirst("/", "");
    } else {
      path_A = '\\\\${uri_A.host}${path_A}';
    }
    return Uri.decodeComponent(path_A.replaceAll("/", "\\"));
  }
  Uri absolutePathToUri(String path_A) {
    var parsed = new ParsedPath.parse_A(path_A, this);
    if (parsed.root.startsWith(r'\\')) {
      var rootParts = parsed.root.split('\\').where((part_A) => part_A != '');
      parsed.parts.insert(0, rootParts.last);
      if (parsed.hasTrailingSeparator) {
        parsed.parts.add("");
      }
      return new Uri(scheme: 'file', host: rootParts.first, pathSegments: parsed.parts);
    } else {
      if (parsed.parts.length == 0 || parsed.hasTrailingSeparator) {
        parsed.parts.add("");
      }
      parsed.parts.insert(0, parsed.root.replaceAll("/", "").replaceAll("\\", ""));
      return new Uri(scheme: 'file', pathSegments: parsed.parts);
    }
  }
}
bool isAlphabetic(int char) => (char >= UPPER_A && char <= UPPER_Z) || (char >= LOWER_A && char <= LOWER_Z);
class CodeGeneratorRequest extends GeneratedMessage {
  static final BuilderInfo _i = new BuilderInfo('CodeGeneratorRequest')
      ..p(1, 'fileToGenerate', PbFieldType.PS)
      ..a(2, 'parameter', PbFieldType.OS)
      ..pp(15, 'protoFile', PbFieldType.PM, FileDescriptorProto.$checkItem, FileDescriptorProto.create_A);
  CodeGeneratorRequest() : super();
  CodeGeneratorRequest.fromBuffer(List<int> i, [ExtensionRegistry r = ExtensionRegistry.EMPTY]) : super.fromBuffer_A(i, r);
  CodeGeneratorRequest clone() => new CodeGeneratorRequest()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i;
  List<String> get fileToGenerate => getField(1);
  String get parameter => getField(2);
  List<FileDescriptorProto> get protoFile => getField(15);
}
class CodeGeneratorResponse_File extends GeneratedMessage {
  static final BuilderInfo _i_A = new BuilderInfo('CodeGeneratorResponse_File')
      ..a(1, 'name', PbFieldType.OS)
      ..a(2, 'insertionPoint', PbFieldType.OS)
      ..a(15, 'content', PbFieldType.OS)
      ..hasRequiredFields = false;
  CodeGeneratorResponse_File() : super();
  CodeGeneratorResponse_File clone() => new CodeGeneratorResponse_File()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_A;
  static CodeGeneratorResponse_File create_B() => new CodeGeneratorResponse_File();
  static void $checkItem_A(CodeGeneratorResponse_File v) {
    if (v is! CodeGeneratorResponse_File) checkItemFailed(v, 'CodeGeneratorResponse_File');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  void set content(String v) {
    setField(15, v);
  }
}
class CodeGeneratorResponse extends GeneratedMessage {
  static final BuilderInfo _i_B = new BuilderInfo('CodeGeneratorResponse')
      ..a(1, 'error', PbFieldType.OS)
      ..pp(15, 'file', PbFieldType.PM, CodeGeneratorResponse_File.$checkItem_A, CodeGeneratorResponse_File.create_B)
      ..hasRequiredFields = false;
  CodeGeneratorResponse() : super();
  CodeGeneratorResponse clone() => new CodeGeneratorResponse()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_B;
  String get error => getField(1);
  void set error(String v) {
    setField(1, v);
  }
  List<CodeGeneratorResponse_File> get file => getField(15);
}
class FileDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_C = new BuilderInfo('FileDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..a(2, 'package', PbFieldType.OS)
      ..p(3, 'dependency', PbFieldType.PS)
      ..p(10, 'publicDependency', PbFieldType.P3)
      ..p(11, 'weakDependency', PbFieldType.P3)
      ..pp(4, 'messageType', PbFieldType.PM, DescriptorProto.$checkItem_B, DescriptorProto.create_C)
      ..pp(5, 'enumType', PbFieldType.PM, EnumDescriptorProto.$checkItem_C, EnumDescriptorProto.create_D)
      ..pp(6, 'service', PbFieldType.PM, ServiceDescriptorProto.$checkItem_D, ServiceDescriptorProto.create_E)
      ..pp(7, 'extension', PbFieldType.PM, FieldDescriptorProto.$checkItem_E, FieldDescriptorProto.create_F)
      ..a(8, 'options', PbFieldType.OM, FileOptions.getDefault, FileOptions.create_G)
      ..a(9, 'sourceCodeInfo', PbFieldType.OM, SourceCodeInfo.getDefault_A, SourceCodeInfo.create_H);
  FileDescriptorProto() : super();
  FileDescriptorProto clone() => new FileDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_C;
  static FileDescriptorProto create_A() => new FileDescriptorProto();
  static void $checkItem(FileDescriptorProto v) {
    if (v is! FileDescriptorProto) checkItemFailed(v, 'FileDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  String get package => getField(2);
  List<DescriptorProto> get messageType => getField(4);
  List<EnumDescriptorProto> get enumType => getField(5);
  List<ServiceDescriptorProto> get service => getField(6);
  List<FieldDescriptorProto> get extension => getField(7);
  FileOptions get options => getField(8);
  bool hasOptions() => hasField(8);
}
class DescriptorProto_ExtensionRange extends GeneratedMessage {
  static final BuilderInfo _i_D = new BuilderInfo('DescriptorProto_ExtensionRange')
      ..a(1, 'start', PbFieldType.O3)
      ..a(2, 'end', PbFieldType.O3)
      ..hasRequiredFields = false;
  DescriptorProto_ExtensionRange() : super();
  DescriptorProto_ExtensionRange clone() => new DescriptorProto_ExtensionRange()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_D;
  static DescriptorProto_ExtensionRange create_I() => new DescriptorProto_ExtensionRange();
  static void $checkItem_F(DescriptorProto_ExtensionRange v) {
    if (v is! DescriptorProto_ExtensionRange) checkItemFailed(v, 'DescriptorProto_ExtensionRange');
  }
  int get start => getField(1);
  int get end => getField(2);
}
class DescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_E = new BuilderInfo('DescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..pp(2, 'field', PbFieldType.PM, FieldDescriptorProto.$checkItem_E, FieldDescriptorProto.create_F)
      ..pp(6, 'extension', PbFieldType.PM, FieldDescriptorProto.$checkItem_E, FieldDescriptorProto.create_F)
      ..pp(3, 'nestedType', PbFieldType.PM, DescriptorProto.$checkItem_B, DescriptorProto.create_C)
      ..pp(4, 'enumType', PbFieldType.PM, EnumDescriptorProto.$checkItem_C, EnumDescriptorProto.create_D)
      ..pp(5, 'extensionRange', PbFieldType.PM, DescriptorProto_ExtensionRange.$checkItem_F, DescriptorProto_ExtensionRange.create_I)
      ..a(7, 'options', PbFieldType.OM, MessageOptions.getDefault_B, MessageOptions.create_J);
  DescriptorProto() : super();
  DescriptorProto clone() => new DescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_E;
  static DescriptorProto create_C() => new DescriptorProto();
  static void $checkItem_B(DescriptorProto v) {
    if (v is! DescriptorProto) checkItemFailed(v, 'DescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  List<FieldDescriptorProto> get field => getField(2);
  List<FieldDescriptorProto> get extension => getField(6);
  List<DescriptorProto> get nestedType => getField(3);
  List<EnumDescriptorProto> get enumType => getField(4);
  List<DescriptorProto_ExtensionRange> get extensionRange => getField(5);
  MessageOptions get options => getField(7);
  bool hasOptions() => hasField(7);
}
class FieldDescriptorProto_Type extends ProtobufEnum {
  static const FieldDescriptorProto_Type TYPE_DOUBLE = const FieldDescriptorProto_Type.__C(1, 'TYPE_DOUBLE');
  static const FieldDescriptorProto_Type TYPE_FLOAT = const FieldDescriptorProto_Type.__C(2, 'TYPE_FLOAT');
  static const FieldDescriptorProto_Type TYPE_INT64 = const FieldDescriptorProto_Type.__C(3, 'TYPE_INT64');
  static const FieldDescriptorProto_Type TYPE_UINT64 = const FieldDescriptorProto_Type.__C(4, 'TYPE_UINT64');
  static const FieldDescriptorProto_Type TYPE_INT32 = const FieldDescriptorProto_Type.__C(5, 'TYPE_INT32');
  static const FieldDescriptorProto_Type TYPE_FIXED64 = const FieldDescriptorProto_Type.__C(6, 'TYPE_FIXED64');
  static const FieldDescriptorProto_Type TYPE_FIXED32 = const FieldDescriptorProto_Type.__C(7, 'TYPE_FIXED32');
  static const FieldDescriptorProto_Type TYPE_BOOL = const FieldDescriptorProto_Type.__C(8, 'TYPE_BOOL');
  static const FieldDescriptorProto_Type TYPE_STRING = const FieldDescriptorProto_Type.__C(9, 'TYPE_STRING');
  static const FieldDescriptorProto_Type TYPE_GROUP = const FieldDescriptorProto_Type.__C(10, 'TYPE_GROUP');
  static const FieldDescriptorProto_Type TYPE_MESSAGE = const FieldDescriptorProto_Type.__C(11, 'TYPE_MESSAGE');
  static const FieldDescriptorProto_Type TYPE_BYTES = const FieldDescriptorProto_Type.__C(12, 'TYPE_BYTES');
  static const FieldDescriptorProto_Type TYPE_UINT32 = const FieldDescriptorProto_Type.__C(13, 'TYPE_UINT32');
  static const FieldDescriptorProto_Type TYPE_ENUM = const FieldDescriptorProto_Type.__C(14, 'TYPE_ENUM');
  static const FieldDescriptorProto_Type TYPE_SFIXED32 = const FieldDescriptorProto_Type.__C(15, 'TYPE_SFIXED32');
  static const FieldDescriptorProto_Type TYPE_SFIXED64 = const FieldDescriptorProto_Type.__C(16, 'TYPE_SFIXED64');
  static const FieldDescriptorProto_Type TYPE_SINT32 = const FieldDescriptorProto_Type.__C(17, 'TYPE_SINT32');
  static const FieldDescriptorProto_Type TYPE_SINT64 = const FieldDescriptorProto_Type.__C(18, 'TYPE_SINT64');
  static const List<FieldDescriptorProto_Type> values_A = const<FieldDescriptorProto_Type>[TYPE_DOUBLE, TYPE_FLOAT, TYPE_INT64, TYPE_UINT64, TYPE_INT32, TYPE_FIXED64, TYPE_FIXED32, TYPE_BOOL, TYPE_STRING, TYPE_GROUP, TYPE_MESSAGE, TYPE_BYTES, TYPE_UINT32, TYPE_ENUM, TYPE_SFIXED32, TYPE_SFIXED64, TYPE_SINT32, TYPE_SINT64];
  static final Map<int, FieldDescriptorProto_Type> _byValue = ProtobufEnum.initByValue(values_A);
  static FieldDescriptorProto_Type valueOf(int value_A) => _byValue[value_A];
  const FieldDescriptorProto_Type.__C(int v, String n) : super(v, n);
}
class FieldDescriptorProto_Label extends ProtobufEnum {
  static const FieldDescriptorProto_Label LABEL_OPTIONAL = const FieldDescriptorProto_Label.__D(1, 'LABEL_OPTIONAL');
  static const FieldDescriptorProto_Label LABEL_REQUIRED = const FieldDescriptorProto_Label.__D(2, 'LABEL_REQUIRED');
  static const FieldDescriptorProto_Label LABEL_REPEATED = const FieldDescriptorProto_Label.__D(3, 'LABEL_REPEATED');
  static const List<FieldDescriptorProto_Label> values_B = const<FieldDescriptorProto_Label>[LABEL_OPTIONAL, LABEL_REQUIRED, LABEL_REPEATED];
  static final Map<int, FieldDescriptorProto_Label> _byValue_A = ProtobufEnum.initByValue(values_B);
  static FieldDescriptorProto_Label valueOf_A(int value_A) => _byValue_A[value_A];
  const FieldDescriptorProto_Label.__D(int v, String n) : super(v, n);
}
class FieldDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_F = new BuilderInfo('FieldDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..a(3, 'number', PbFieldType.O3)
      ..e(4, 'label', PbFieldType.OE, FieldDescriptorProto_Label.LABEL_OPTIONAL, FieldDescriptorProto_Label.valueOf_A)
      ..e(5, 'type', PbFieldType.OE, FieldDescriptorProto_Type.TYPE_DOUBLE, FieldDescriptorProto_Type.valueOf)
      ..a(6, 'typeName', PbFieldType.OS)
      ..a(2, 'extendee', PbFieldType.OS)
      ..a(7, 'defaultValue', PbFieldType.OS)
      ..a(8, 'options', PbFieldType.OM, FieldOptions.getDefault_C, FieldOptions.create_K);
  FieldDescriptorProto() : super();
  FieldDescriptorProto clone() => new FieldDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_F;
  static FieldDescriptorProto create_F() => new FieldDescriptorProto();
  static void $checkItem_E(FieldDescriptorProto v) {
    if (v is! FieldDescriptorProto) checkItemFailed(v, 'FieldDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  int get number => getField(3);
  FieldDescriptorProto_Label get label => getField(4);
  FieldDescriptorProto_Type get type => getField(5);
  String get typeName => getField(6);
  String get extendee => getField(2);
  String get defaultValue => getField(7);
  bool hasDefaultValue() => hasField(7);
  FieldOptions get options => getField(8);
  bool hasOptions() => hasField(8);
}
class EnumDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_G = new BuilderInfo('EnumDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..pp(2, 'value', PbFieldType.PM, EnumValueDescriptorProto.$checkItem_G, EnumValueDescriptorProto.create_L)
      ..a(3, 'options', PbFieldType.OM, EnumOptions.getDefault_D, EnumOptions.create_M);
  EnumDescriptorProto() : super();
  EnumDescriptorProto clone() => new EnumDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_G;
  static EnumDescriptorProto create_D() => new EnumDescriptorProto();
  static void $checkItem_C(EnumDescriptorProto v) {
    if (v is! EnumDescriptorProto) checkItemFailed(v, 'EnumDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  List<EnumValueDescriptorProto> get value => getField(2);
  EnumOptions get options => getField(3);
  bool hasOptions() => hasField(3);
}
class EnumValueDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_H = new BuilderInfo('EnumValueDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..a(2, 'number', PbFieldType.O3)
      ..a(3, 'options', PbFieldType.OM, EnumValueOptions.getDefault_E, EnumValueOptions.create_N);
  EnumValueDescriptorProto() : super();
  EnumValueDescriptorProto clone() => new EnumValueDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_H;
  static EnumValueDescriptorProto create_L() => new EnumValueDescriptorProto();
  static void $checkItem_G(EnumValueDescriptorProto v) {
    if (v is! EnumValueDescriptorProto) checkItemFailed(v, 'EnumValueDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  int get number => getField(2);
  EnumValueOptions get options => getField(3);
  bool hasOptions() => hasField(3);
}
class ServiceDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_I = new BuilderInfo('ServiceDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..pp(2, 'method', PbFieldType.PM, MethodDescriptorProto.$checkItem_H, MethodDescriptorProto.create_O)
      ..pp(4, 'stream', PbFieldType.PM, StreamDescriptorProto.$checkItem_I, StreamDescriptorProto.create_P)
      ..a(3, 'options', PbFieldType.OM, ServiceOptions.getDefault_F, ServiceOptions.create_Q);
  ServiceDescriptorProto() : super();
  ServiceDescriptorProto clone() => new ServiceDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_I;
  static ServiceDescriptorProto create_E() => new ServiceDescriptorProto();
  static void $checkItem_D(ServiceDescriptorProto v) {
    if (v is! ServiceDescriptorProto) checkItemFailed(v, 'ServiceDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  List<MethodDescriptorProto> get method => getField(2);
  ServiceOptions get options => getField(3);
  bool hasOptions() => hasField(3);
}
class MethodDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_J = new BuilderInfo('MethodDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..a(2, 'inputType', PbFieldType.OS)
      ..a(3, 'outputType', PbFieldType.OS)
      ..a(4, 'options', PbFieldType.OM, MethodOptions.getDefault_G, MethodOptions.create_R);
  MethodDescriptorProto() : super();
  MethodDescriptorProto clone() => new MethodDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_J;
  static MethodDescriptorProto create_O() => new MethodDescriptorProto();
  static void $checkItem_H(MethodDescriptorProto v) {
    if (v is! MethodDescriptorProto) checkItemFailed(v, 'MethodDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  String get inputType => getField(2);
  String get outputType => getField(3);
  MethodOptions get options => getField(4);
  bool hasOptions() => hasField(4);
}
class StreamDescriptorProto extends GeneratedMessage {
  static final BuilderInfo _i_K = new BuilderInfo('StreamDescriptorProto')
      ..a(1, 'name', PbFieldType.OS)
      ..a(2, 'clientMessageType', PbFieldType.OS)
      ..a(3, 'serverMessageType', PbFieldType.OS)
      ..a(4, 'options', PbFieldType.OM, StreamOptions.getDefault_H, StreamOptions.create_S);
  StreamDescriptorProto() : super();
  StreamDescriptorProto clone() => new StreamDescriptorProto()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_K;
  static StreamDescriptorProto create_P() => new StreamDescriptorProto();
  static void $checkItem_I(StreamDescriptorProto v) {
    if (v is! StreamDescriptorProto) checkItemFailed(v, 'StreamDescriptorProto');
  }
  String get name => getField(1);
  void set name(String v) {
    setField(1, v);
  }
  StreamOptions get options => getField(4);
  bool hasOptions() => hasField(4);
}
class FileOptions_OptimizeMode extends ProtobufEnum {
  static const FileOptions_OptimizeMode SPEED = const FileOptions_OptimizeMode.__E(1, 'SPEED');
  static const FileOptions_OptimizeMode CODE_SIZE = const FileOptions_OptimizeMode.__E(2, 'CODE_SIZE');
  static const FileOptions_OptimizeMode LITE_RUNTIME = const FileOptions_OptimizeMode.__E(3, 'LITE_RUNTIME');
  static const List<FileOptions_OptimizeMode> values_C = const<FileOptions_OptimizeMode>[SPEED, CODE_SIZE, LITE_RUNTIME];
  static final Map<int, FileOptions_OptimizeMode> _byValue_B = ProtobufEnum.initByValue(values_C);
  static FileOptions_OptimizeMode valueOf_B(int value_A) => _byValue_B[value_A];
  const FileOptions_OptimizeMode.__E(int v, String n) : super(v, n);
}
class FileOptions extends GeneratedMessage {
  static final BuilderInfo _i_L = new BuilderInfo('FileOptions')
      ..a(1, 'javaPackage', PbFieldType.OS)
      ..a(8, 'javaOuterClassname', PbFieldType.OS)
      ..a(10, 'javaMultipleFiles', PbFieldType.OB)
      ..a(20, 'javaGenerateEqualsAndHash', PbFieldType.OB)
      ..e(9, 'optimizeFor', PbFieldType.OE, FileOptions_OptimizeMode.SPEED, FileOptions_OptimizeMode.valueOf_B)
      ..a(16, 'ccGenericServices', PbFieldType.OB)
      ..a(17, 'javaGenericServices', PbFieldType.OB)
      ..a(18, 'pyGenericServices', PbFieldType.OB)
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  FileOptions() : super();
  FileOptions clone() => new FileOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_L;
  static FileOptions create_G() => new FileOptions();
  static FileOptions getDefault() {
    if (_defaultInstance == null) _defaultInstance = new _ReadonlyFileOptions();
    return _defaultInstance;
  }
  static FileOptions _defaultInstance;
}
class _ReadonlyFileOptions extends FileOptions with ReadonlyMessageMixin {}
class MessageOptions extends GeneratedMessage {
  static final BuilderInfo _i_M = new BuilderInfo('MessageOptions')
      ..a(1, 'messageSetWireFormat', PbFieldType.OB)
      ..a(2, 'noStandardDescriptorAccessor', PbFieldType.OB)
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  MessageOptions() : super();
  MessageOptions clone() => new MessageOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_M;
  static MessageOptions create_J() => new MessageOptions();
  static MessageOptions getDefault_B() {
    if (_defaultInstance_A == null) _defaultInstance_A = new _ReadonlyMessageOptions();
    return _defaultInstance_A;
  }
  static MessageOptions _defaultInstance_A;
}
class _ReadonlyMessageOptions extends MessageOptions with ReadonlyMessageMixin {}
class FieldOptions_CType extends ProtobufEnum {
  static const FieldOptions_CType STRING = const FieldOptions_CType.__F(0, 'STRING');
  static const List<FieldOptions_CType> values_D = const<FieldOptions_CType>[STRING];
  static final Map<int, FieldOptions_CType> _byValue_C = ProtobufEnum.initByValue(values_D);
  static FieldOptions_CType valueOf_C(int value_A) => _byValue_C[value_A];
  const FieldOptions_CType.__F(int v, String n) : super(v, n);
}
class FieldOptions extends GeneratedMessage {
  static final BuilderInfo _i_N = new BuilderInfo('FieldOptions')
      ..e(1, 'ctype', PbFieldType.OE, FieldOptions_CType.STRING, FieldOptions_CType.valueOf_C)
      ..a(2, 'packed', PbFieldType.OB)
      ..a(5, 'lazy', PbFieldType.OB)
      ..a(3, 'deprecated', PbFieldType.OB)
      ..a(9, 'experimentalMapKey', PbFieldType.OS)
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  FieldOptions() : super();
  FieldOptions clone() => new FieldOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_N;
  static FieldOptions create_K() => new FieldOptions();
  static FieldOptions getDefault_C() {
    if (_defaultInstance_B == null) _defaultInstance_B = new _ReadonlyFieldOptions();
    return _defaultInstance_B;
  }
  static FieldOptions _defaultInstance_B;
  bool get packed => getField(2);
}
class _ReadonlyFieldOptions extends FieldOptions with ReadonlyMessageMixin {}
class EnumOptions extends GeneratedMessage {
  static final BuilderInfo _i_O = new BuilderInfo('EnumOptions')
      ..a(2, 'allowAlias', PbFieldType.OB, true)
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  EnumOptions() : super();
  EnumOptions clone() => new EnumOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_O;
  static EnumOptions create_M() => new EnumOptions();
  static EnumOptions getDefault_D() {
    if (_defaultInstance_C == null) _defaultInstance_C = new _ReadonlyEnumOptions();
    return _defaultInstance_C;
  }
  static EnumOptions _defaultInstance_C;
}
class _ReadonlyEnumOptions extends EnumOptions with ReadonlyMessageMixin {}
class EnumValueOptions extends GeneratedMessage {
  static final BuilderInfo _i_P = new BuilderInfo('EnumValueOptions')
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  EnumValueOptions() : super();
  EnumValueOptions clone() => new EnumValueOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_P;
  static EnumValueOptions create_N() => new EnumValueOptions();
  static EnumValueOptions getDefault_E() {
    if (_defaultInstance_D == null) _defaultInstance_D = new _ReadonlyEnumValueOptions();
    return _defaultInstance_D;
  }
  static EnumValueOptions _defaultInstance_D;
}
class _ReadonlyEnumValueOptions extends EnumValueOptions with ReadonlyMessageMixin {}
class ServiceOptions extends GeneratedMessage {
  static final BuilderInfo _i_Q = new BuilderInfo('ServiceOptions')
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  ServiceOptions() : super();
  ServiceOptions clone() => new ServiceOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_Q;
  static ServiceOptions create_Q() => new ServiceOptions();
  static ServiceOptions getDefault_F() {
    if (_defaultInstance_E == null) _defaultInstance_E = new _ReadonlyServiceOptions();
    return _defaultInstance_E;
  }
  static ServiceOptions _defaultInstance_E;
}
class _ReadonlyServiceOptions extends ServiceOptions with ReadonlyMessageMixin {}
class MethodOptions extends GeneratedMessage {
  static final BuilderInfo _i_R = new BuilderInfo('MethodOptions')
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  MethodOptions() : super();
  MethodOptions clone() => new MethodOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_R;
  static MethodOptions create_R() => new MethodOptions();
  static MethodOptions getDefault_G() {
    if (_defaultInstance_F == null) _defaultInstance_F = new _ReadonlyMethodOptions();
    return _defaultInstance_F;
  }
  static MethodOptions _defaultInstance_F;
}
class _ReadonlyMethodOptions extends MethodOptions with ReadonlyMessageMixin {}
class StreamOptions extends GeneratedMessage {
  static final BuilderInfo _i_S = new BuilderInfo('StreamOptions')
      ..pp(999, 'uninterpretedOption', PbFieldType.PM, UninterpretedOption.$checkItem_J, UninterpretedOption.create_T)
      ..hasExtensions = true;
  StreamOptions() : super();
  StreamOptions clone() => new StreamOptions()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_S;
  static StreamOptions create_S() => new StreamOptions();
  static StreamOptions getDefault_H() {
    if (_defaultInstance_G == null) _defaultInstance_G = new _ReadonlyStreamOptions();
    return _defaultInstance_G;
  }
  static StreamOptions _defaultInstance_G;
}
class _ReadonlyStreamOptions extends StreamOptions with ReadonlyMessageMixin {}
class UninterpretedOption_NamePart extends GeneratedMessage {
  static final BuilderInfo _i_T = new BuilderInfo('UninterpretedOption_NamePart')
      ..a(1, 'namePart', PbFieldType.QS)
      ..a(2, 'isExtension', PbFieldType.QB);
  UninterpretedOption_NamePart() : super();
  UninterpretedOption_NamePart clone() => new UninterpretedOption_NamePart()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_T;
  static UninterpretedOption_NamePart create_U() => new UninterpretedOption_NamePart();
  static void $checkItem_K(UninterpretedOption_NamePart v) {
    if (v is! UninterpretedOption_NamePart) checkItemFailed(v, 'UninterpretedOption_NamePart');
  }
}
class UninterpretedOption extends GeneratedMessage {
  static final BuilderInfo _i_U = new BuilderInfo('UninterpretedOption')
      ..pp(2, 'name', PbFieldType.PM, UninterpretedOption_NamePart.$checkItem_K, UninterpretedOption_NamePart.create_U)
      ..a(3, 'identifierValue', PbFieldType.OS)
      ..a(4, 'positiveIntValue', PbFieldType.OU6, Int64.ZERO_A)
      ..a(5, 'negativeIntValue', PbFieldType.O6, Int64.ZERO_A)
      ..a(6, 'doubleValue', PbFieldType.OD)
      ..a(7, 'stringValue', PbFieldType.OY)
      ..a(8, 'aggregateValue', PbFieldType.OS);
  UninterpretedOption() : super();
  UninterpretedOption clone() => new UninterpretedOption()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_U;
  static UninterpretedOption create_T() => new UninterpretedOption();
  static void $checkItem_J(UninterpretedOption v) {
    if (v is! UninterpretedOption) checkItemFailed(v, 'UninterpretedOption');
  }
  List<UninterpretedOption_NamePart> get name => getField(2);
}
class SourceCodeInfo_Location extends GeneratedMessage {
  static final BuilderInfo _i_V = new BuilderInfo('SourceCodeInfo_Location')
      ..p(1, 'path', PbFieldType.K3)
      ..p(2, 'span', PbFieldType.K3)
      ..hasRequiredFields = false;
  SourceCodeInfo_Location() : super();
  SourceCodeInfo_Location clone() => new SourceCodeInfo_Location()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_V;
  static SourceCodeInfo_Location create_V() => new SourceCodeInfo_Location();
  static void $checkItem_L(SourceCodeInfo_Location v) {
    if (v is! SourceCodeInfo_Location) checkItemFailed(v, 'SourceCodeInfo_Location');
  }
  List<int> get path => getField(1);
}
class SourceCodeInfo extends GeneratedMessage {
  static final BuilderInfo _i_W = new BuilderInfo('SourceCodeInfo')
      ..pp(1, 'location', PbFieldType.PM, SourceCodeInfo_Location.$checkItem_L, SourceCodeInfo_Location.create_V)
      ..hasRequiredFields = false;
  SourceCodeInfo() : super();
  SourceCodeInfo clone() => new SourceCodeInfo()
      ..mergeFromMessage(this);
  BuilderInfo get info_ => _i_W;
  static SourceCodeInfo create_H() => new SourceCodeInfo();
  static SourceCodeInfo getDefault_A() {
    if (_defaultInstance_H == null) _defaultInstance_H = new _ReadonlySourceCodeInfo();
    return _defaultInstance_H;
  }
  static SourceCodeInfo _defaultInstance_H;
}
class _ReadonlySourceCodeInfo extends SourceCodeInfo with ReadonlyMessageMixin {}
const _UTF8 = const Utf8Codec(allowMalformed: true);
class BuilderInfo {
  final String messageName;
  final Map<int, FieldInfo> fieldInfo = new Map<int, FieldInfo>();
  final Map<String, FieldInfo> byTagAsString = <String, FieldInfo>{};
  final Map<String, FieldInfo> byName = <String, FieldInfo>{};
  bool hasExtensions = false;
  bool hasRequiredFields = true;
  List _sortedByTag;
  BuilderInfo(this.messageName);
  void add(int tagNumber_A, String name_A, int fieldType_A, dynamic defaultOrMaker, CreateBuilderFunc subBuilder_A, ValueOfFunc valueOf_D) {
    var index_A = fieldInfo.length;
    addField(new FieldInfo(name_A, tagNumber_A, index_A, fieldType_A, defaultOrMaker, subBuilder_A, valueOf_D));
  }
  void addRepeated(int tagNumber_A, String name_A, int fieldType_A, CheckFunc check_A, CreateBuilderFunc subBuilder_A, ValueOfFunc valueOf_D) {
    var index_A = fieldInfo.length;
    addField(new FieldInfo.repeated(name_A, tagNumber_A, index_A, fieldType_A, check_A, subBuilder_A, valueOf_D));
  }
  void addField(FieldInfo fi) {
    fieldInfo[fi.tagNumber] = fi;
    byTagAsString["${fi.tagNumber}"] = fi;
    byName[fi.name] = fi;
  }
  void a(int tagNumber_A, String name_A, int fieldType_A, [dynamic defaultOrMaker, CreateBuilderFunc subBuilder_A, ValueOfFunc valueOf_D]) {
    add(tagNumber_A, name_A, fieldType_A, defaultOrMaker, subBuilder_A, valueOf_D);
  }
  void e(int tagNumber_A, String name_A, int fieldType_A, dynamic defaultOrMaker, ValueOfFunc valueOf_D) {
    add(tagNumber_A, name_A, fieldType_A, defaultOrMaker, null, valueOf_D);
  }
  void p(int tagNumber_A, String name_A, int fieldType_A) {
    assert(!_isGroupOrMessage(fieldType_A) && !_isEnum(fieldType_A));
    addRepeated(tagNumber_A, name_A, fieldType_A, getCheckFunction(fieldType_A), null, null);
  }
  void pp(int tagNumber_A, String name_A, int fieldType_A, CheckFunc check_A, [CreateBuilderFunc subBuilder_A, ValueOfFunc valueOf_D]) {
    assert(_isGroupOrMessage(fieldType_A) || _isEnum(fieldType_A));
    addRepeated(tagNumber_A, name_A, fieldType_A, check_A, subBuilder_A, valueOf_D);
  }
  defaultValue(int tagNumber_A) {
    MakeDefaultFunc func = makeDefault(tagNumber_A);
    return func == null ? null : func();
  }
  MakeDefaultFunc makeDefault(int tagNumber_A) {
    FieldInfo i = fieldInfo[tagNumber_A];
    return i != null ? i.makeDefault : null;
  }
  CreateBuilderFunc subBuilder(int tagNumber_A) {
    FieldInfo i = fieldInfo[tagNumber_A];
    return i != null ? i.subBuilder : null;
  }
  int tagNumber(String fieldName_A) {
    FieldInfo i = byName[fieldName_A];
    return i != null ? i.tagNumber : null;
  }
  ValueOfFunc valueOfFunc(int tagNumber_A) {
    FieldInfo i = fieldInfo[tagNumber_A];
    return i != null ? i.valueOf_D : null;
  }
  List<FieldInfo> get sortedByTag {
    if (_sortedByTag != null) return _sortedByTag;
    _sortedByTag = new List<FieldInfo>.from(fieldInfo.values)
        ..sort((a_A, b) => a_A.tagNumber.compareTo(b.tagNumber));
    return _sortedByTag;
  }
  GeneratedMessage _makeEmptyMessage(int tagNumber_A, ExtensionRegistry extensionRegistry) {
    CreateBuilderFunc subBuilderFunc = subBuilder(tagNumber_A);
    if (subBuilderFunc == null && extensionRegistry != null) {
      subBuilderFunc = extensionRegistry.getExtension(messageName, tagNumber_A).subBuilder;
    }
    return subBuilderFunc();
  }
  _decodeEnum(int tagNumber_A, ExtensionRegistry registry, int rawValue) {
    ValueOfFunc f = valueOfFunc(tagNumber_A);
    if (f == null && registry != null) {
      f = registry.getExtension(messageName, tagNumber_A).valueOf_D;
    }
    return f(rawValue);
  }
}
void _writeToCodedBufferWriter(_FieldSet fs, CodedBufferWriter out) {
  for (var fi in fs._infosSortedByTag) {
    var value_A = fs._values_A[fi.index];
    if (value_A == null) continue;
    out.writeField(fi.tagNumber, fi.type, value_A);
  }
  if (fs._hasExtensions) {
    for (var tagNumber in sorted(fs._extensions._tagNumbers)) {
      var fi = fs._extensions._getInfoOrNull(tagNumber);
      out.writeField(tagNumber, fi.type, fs._extensions._getFieldOrNull(fi));
    }
  }
  if (fs.hasUnknownFields) {
    fs._unknownFields.writeToCodedBufferWriter(out);
  }
}
void _mergeFromCodedBufferReader(_FieldSet fs, CodedBufferReader input_A, ExtensionRegistry registry) {
  assert(registry != null);
  void readPackableToList(int wireType, FieldInfo fi, Function readToList) {
    List list_A = fs._ensureRepeatedField(fi);
    if (wireType == WIRETYPE_LENGTH_DELIMITED) {
      input_A._withLimit(input_A.readInt32(), () {
        while (!input_A.isAtEnd()) {
          readToList(list_A);
        }
      });
    } else {
      readToList(list_A);
    }
  }
  void readPackable(int wireType, FieldInfo fi, Function readFunc) {
    void readToList(List list_A) => list_A.add(readFunc());
    readPackableToList(wireType, fi, readToList);
  }
  while (true) {
    int tag = input_A.readTag();
    if (tag == 0) return;
    int wireType = tag & 0x7;
    int tagNumber = tag >> 3;
    FieldInfo fi = fs._nonExtensionInfo(tagNumber);
    if (fi == null) {
      fi = registry.getExtension(fs._messageName, tagNumber);
    }
    if (fi == null || !_wireTypeMatches(fi.type, wireType)) {
      if (!fs._ensureUnknownFields().mergeFieldFromBuffer(tag, input_A)) {
        return;
      }
      continue;
    }
    int fieldType = fi.type;
    fieldType &= ~(PbFieldType._PACKED_BIT | PbFieldType._REQUIRED_BIT);
    switch (fieldType) {
      case PbFieldType._OPTIONAL_BOOL:
        fs._setFieldUnchecked(fi, input_A.readBool());
        break;

      case PbFieldType._OPTIONAL_BYTES:
        fs._setFieldUnchecked(fi, input_A.readBytes());
        break;

      case PbFieldType._OPTIONAL_STRING:
        fs._setFieldUnchecked(fi, input_A.readString());
        break;

      case PbFieldType._OPTIONAL_FLOAT:
        fs._setFieldUnchecked(fi, input_A.readFloat());
        break;

      case PbFieldType._OPTIONAL_DOUBLE:
        fs._setFieldUnchecked(fi, input_A.readDouble());
        break;

      case PbFieldType._OPTIONAL_ENUM:
        int rawValue = input_A.readEnum();
        var value_A = fs._meta._decodeEnum(tagNumber, registry, rawValue);
        if (value_A == null) {
          var unknown = fs._ensureUnknownFields();
          unknown.mergeVarintField(tagNumber, new Int64(rawValue));
        } else {
          fs._setFieldUnchecked(fi, value_A);
        }
        break;

      case PbFieldType._OPTIONAL_GROUP:
        GeneratedMessage subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
        var oldValue = fs._getFieldOrNull(fi);
        if (oldValue != null) {
          subMessage.mergeFromMessage(oldValue);
        }
        input_A.readGroup(tagNumber, subMessage, registry);
        fs._setFieldUnchecked(fi, subMessage);
        break;

      case PbFieldType._OPTIONAL_INT32:
        fs._setFieldUnchecked(fi, input_A.readInt32());
        break;

      case PbFieldType._OPTIONAL_INT64:
        fs._setFieldUnchecked(fi, input_A.readInt64());
        break;

      case PbFieldType._OPTIONAL_SINT32:
        fs._setFieldUnchecked(fi, input_A.readSint32());
        break;

      case PbFieldType._OPTIONAL_SINT64:
        fs._setFieldUnchecked(fi, input_A.readSint64());
        break;

      case PbFieldType._OPTIONAL_UINT32:
        fs._setFieldUnchecked(fi, input_A.readUint32());
        break;

      case PbFieldType._OPTIONAL_UINT64:
        fs._setFieldUnchecked(fi, input_A.readUint64());
        break;

      case PbFieldType._OPTIONAL_FIXED32:
        fs._setFieldUnchecked(fi, input_A.readFixed32());
        break;

      case PbFieldType._OPTIONAL_FIXED64:
        fs._setFieldUnchecked(fi, input_A.readFixed64());
        break;

      case PbFieldType._OPTIONAL_SFIXED32:
        fs._setFieldUnchecked(fi, input_A.readSfixed32());
        break;

      case PbFieldType._OPTIONAL_SFIXED64:
        fs._setFieldUnchecked(fi, input_A.readSfixed64());
        break;

      case PbFieldType._OPTIONAL_MESSAGE:
        GeneratedMessage subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
        var oldValue = fs._getFieldOrNull(fi);
        if (oldValue != null) {
          subMessage.mergeFromMessage(oldValue);
        }
        input_A.readMessage(subMessage, registry);
        fs._setFieldUnchecked(fi, subMessage);
        break;

      case PbFieldType._REPEATED_BOOL:
        readPackable(wireType, fi, input_A.readBool);
        break;

      case PbFieldType._REPEATED_BYTES:
        fs._ensureRepeatedField(fi).add(input_A.readBytes());
        break;

      case PbFieldType._REPEATED_STRING:
        fs._ensureRepeatedField(fi).add(input_A.readString());
        break;

      case PbFieldType._REPEATED_FLOAT:
        readPackable(wireType, fi, input_A.readFloat);
        break;

      case PbFieldType._REPEATED_DOUBLE:
        readPackable(wireType, fi, input_A.readDouble);
        break;

      case PbFieldType._REPEATED_ENUM:
        readPackableToList(wireType, fi, (List list_A) {
          int rawValue = input_A.readEnum();
          var value_A = fs._meta._decodeEnum(tagNumber, registry, rawValue);
          if (value_A == null) {
            var unknown = fs._ensureUnknownFields();
            unknown.mergeVarintField(tagNumber, new Int64(rawValue));
          } else {
            list_A.add(value_A);
          }
        });
        break;

      case PbFieldType._REPEATED_GROUP:
        GeneratedMessage subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
        input_A.readGroup(tagNumber, subMessage, registry);
        fs._ensureRepeatedField(fi).add(subMessage);
        break;

      case PbFieldType._REPEATED_INT32:
        readPackable(wireType, fi, input_A.readInt32);
        break;

      case PbFieldType._REPEATED_INT64:
        readPackable(wireType, fi, input_A.readInt64);
        break;

      case PbFieldType._REPEATED_SINT32:
        readPackable(wireType, fi, input_A.readSint32);
        break;

      case PbFieldType._REPEATED_SINT64:
        readPackable(wireType, fi, input_A.readSint64);
        break;

      case PbFieldType._REPEATED_UINT32:
        readPackable(wireType, fi, input_A.readUint32);
        break;

      case PbFieldType._REPEATED_UINT64:
        readPackable(wireType, fi, input_A.readUint64);
        break;

      case PbFieldType._REPEATED_FIXED32:
        readPackable(wireType, fi, input_A.readFixed32);
        break;

      case PbFieldType._REPEATED_FIXED64:
        readPackable(wireType, fi, input_A.readFixed64);
        break;

      case PbFieldType._REPEATED_SFIXED32:
        readPackable(wireType, fi, input_A.readSfixed32);
        break;

      case PbFieldType._REPEATED_SFIXED64:
        readPackable(wireType, fi, input_A.readSfixed64);
        break;

      case PbFieldType._REPEATED_MESSAGE:
        GeneratedMessage subMessage = fs._meta._makeEmptyMessage(tagNumber, registry);
        input_A.readMessage(subMessage, registry);
        fs._ensureRepeatedField(fi).add(subMessage);
        break;

      default:
        throw 'Unknown field type ${fieldType}';
    }
  }
}
class CodedBufferReader {
  static const int DEFAULT_RECURSION_LIMIT = 64;
  static const int DEFAULT_SIZE_LIMIT = 64 << 20;
  final Uint8List _buffer_B;
  int _bufferPos = 0;
  int _currentLimit = -1;
  int _lastTag = 0;
  int _recursionDepth = 0;
  final int _recursionLimit;
  final int _sizeLimit;
  CodedBufferReader(List<int> buffer_A, {int recursionLimit: DEFAULT_RECURSION_LIMIT, int sizeLimit: DEFAULT_SIZE_LIMIT}) : _buffer_B = buffer_A is Uint8List ? buffer_A : new Uint8List(buffer_A.length)
      ..setRange(0, buffer_A.length, buffer_A), _recursionLimit = recursionLimit, _sizeLimit = _A.min(sizeLimit, buffer_A.length) {
    _currentLimit = _sizeLimit;
  }
  void checkLastTagWas(int value_A) {
    if (_lastTag != value_A) {
      throw new InvalidProtocolBufferException.invalidEndTag();
    }
  }
  bool isAtEnd() => _bufferPos >= _currentLimit;
  void _withLimit(int byteLimit, callback_A) {
    if (byteLimit < 0) {
      throw new ArgumentError('CodedBufferReader encountered an embedded string or message' ' which claimed to have negative size.');
    }
    byteLimit += _bufferPos;
    int oldLimit = _currentLimit;
    if ((oldLimit != -1 && byteLimit > oldLimit) || byteLimit > _sizeLimit) {
      throw new InvalidProtocolBufferException.truncatedMessage();
    }
    _currentLimit = byteLimit;
    callback_A();
    _currentLimit = oldLimit;
  }
  void _checkLimit(int increment) {
    assert(_currentLimit != -1);
    _bufferPos += increment;
    if (_bufferPos > _currentLimit) {
      throw new InvalidProtocolBufferException.truncatedMessage();
    }
  }
  void readGroup(int fieldNumber, GeneratedMessage message_A, ExtensionRegistry extensionRegistry) {
    if (_recursionDepth >= _recursionLimit) {
      throw new InvalidProtocolBufferException.recursionLimitExceeded();
    }
    ++_recursionDepth;
    message_A.mergeFromCodedBufferReader(this, extensionRegistry);
    checkLastTagWas(makeTag(fieldNumber, WIRETYPE_END_GROUP));
    --_recursionDepth;
  }
  UnknownFieldSet readUnknownFieldSetGroup(int fieldNumber) {
    if (_recursionDepth >= _recursionLimit) {
      throw new InvalidProtocolBufferException.recursionLimitExceeded();
    }
    ++_recursionDepth;
    UnknownFieldSet unknownFieldSet = new UnknownFieldSet();
    unknownFieldSet.mergeFromCodedBufferReader(this);
    checkLastTagWas(makeTag(fieldNumber, WIRETYPE_END_GROUP));
    --_recursionDepth;
    return unknownFieldSet;
  }
  void readMessage(GeneratedMessage message_A, ExtensionRegistry extensionRegistry) {
    int length_A = readInt32();
    if (_recursionDepth >= _recursionLimit) {
      throw new InvalidProtocolBufferException.recursionLimitExceeded();
    }
    if (length_A < 0) {
      throw new ArgumentError('CodedBufferReader encountered an embedded string or message' ' which claimed to have negative size.');
    }
    int oldLimit = _currentLimit;
    _currentLimit = _bufferPos + length_A;
    if (_currentLimit > oldLimit) {
      throw new InvalidProtocolBufferException.truncatedMessage();
    }
    ++_recursionDepth;
    message_A.mergeFromCodedBufferReader(this, extensionRegistry);
    checkLastTagWas(0);
    --_recursionDepth;
    _currentLimit = oldLimit;
  }
  int readEnum() => readInt32();
  int readInt32() => _readRawVarint32();
  Int64 readInt64() => _readRawVarint64();
  int readUint32() => _readRawVarint32(false);
  Int64 readUint64() => _readRawVarint64();
  int readSint32() => _decodeZigZag32(readUint32());
  Int64 readSint64() => _decodeZigZag64(readUint64());
  int readFixed32() => _readByteData(4).getUint32(0, Endianness.LITTLE_ENDIAN);
  Int64 readFixed64() => readSfixed64();
  int readSfixed32() => _readByteData(4).getInt32(0, Endianness.LITTLE_ENDIAN);
  Int64 readSfixed64() {
    var data_A = _readByteData(8);
    var view_A = new Uint8List.view(data_A.buffer, data_A.offsetInBytes, 8);
    return new Int64.fromBytes(view_A);
  }
  bool readBool() => _readRawVarint32() != 0;
  List<int> readBytes() {
    int length_A = readInt32();
    _checkLimit(length_A);
    return new Uint8List.view(_buffer_B.buffer, _buffer_B.offsetInBytes + _bufferPos - length_A, length_A);
  }
  String readString() => _UTF8.decode(readBytes());
  double readFloat() => _readByteData(4).getFloat32(0, Endianness.LITTLE_ENDIAN);
  double readDouble() => _readByteData(8).getFloat64(0, Endianness.LITTLE_ENDIAN);
  int readTag() {
    if (isAtEnd()) {
      _lastTag = 0;
      return 0;
    }
    _lastTag = readInt32();
    if (getTagFieldNumber(_lastTag) == 0) {
      throw new InvalidProtocolBufferException.invalidTag();
    }
    return _lastTag;
  }
  static int _decodeZigZag32(int value_A) {
    if ((value_A & 0x1) == 1) value_A = -value_A;
    return value_A >> 1;
  }
  static Int64 _decodeZigZag64(Int64 value_A) {
    if ((value_A & 0x1) == 1) value_A = -value_A;
    return value_A >> 1;
  }
  int _readRawVarintByte() {
    _checkLimit(1);
    return _buffer_B[_bufferPos - 1];
  }
  int _readRawVarint32([bool signed = true]) {
    int bytes = _currentLimit - _bufferPos;
    if (bytes > 10) bytes = 10;
    int result_A = 0;
    for (int i = 0; i < bytes; i++) {
      int byte = _buffer_B[_bufferPos++];
      result_A |= (byte & 0x7f) << (i * 7);
      if ((byte & 0x80) == 0) {
        result_A &= 0xffffffff;
        return signed ? result_A - 2 * (0x80000000 & result_A) : result_A;
      }
    }
    throw new InvalidProtocolBufferException.malformedVarint();
  }
  Int64 _readRawVarint64() {
    int lo = 0;
    int hi = 0;
    for (int i = 0; i < 4; i++) {
      int byte = _readRawVarintByte();
      lo |= (byte & 0x7f) << (i * 7);
      if ((byte & 0x80) == 0) return new Int64.fromInts(hi, lo);
    }
    int byte = _readRawVarintByte();
    lo |= (byte & 0xf) << 28;
    hi = (byte >> 4) & 0x7;
    if ((byte & 0x80) == 0) {
      return new Int64.fromInts(hi, lo);
    }
    for (int i = 0; i < 5; i++) {
      int byte = _readRawVarintByte();
      hi |= (byte & 0x7f) << ((i * 7) + 3);
      if ((byte & 0x80) == 0) return new Int64.fromInts(hi, lo);
    }
    throw new InvalidProtocolBufferException.malformedVarint();
  }
  ByteData _readByteData(int sizeInBytes) {
    _checkLimit(sizeInBytes);
    return new ByteData.view(_buffer_B.buffer, _buffer_B.offsetInBytes + _bufferPos - sizeInBytes, sizeInBytes);
  }
}
class CodedBufferWriter {
  final List<TypedData> _output = <TypedData>[];
  int _runningSizeInBytes = 0;
  static final _WRITE_FUNCTION_MAP = _makeWriteFunctionMap();
  static ByteData _toVarint32(int value_A) {
    Uint8List result_A = new Uint8List(5);
    int i = 0;
    while (value_A >= 0x80) {
      result_A[i++] = 0x80 | (value_A & 0x7f);
      value_A >>= 7;
    }
    result_A[i++] = value_A;
    return new ByteData.view(result_A.buffer, 0, i);
  }
  static ByteData _toVarint64(Int64 value_A) {
    Uint8List result_A = new Uint8List(10);
    int i = 0;
    ByteData bytes = new ByteData.view(new Uint8List.fromList(value_A.toBytes()).buffer, 0, 8);
    int lo = bytes.getUint32(0, Endianness.LITTLE_ENDIAN);
    int hi = bytes.getUint32(4, Endianness.LITTLE_ENDIAN);
    while (hi > 0 || lo >= 0x80) {
      result_A[i++] = 0x80 | (lo & 0x7f);
      lo = (lo >> 7) | ((hi & 0x7f) << 25);
      hi >>= 7;
    }
    result_A[i++] = lo;
    return new ByteData.view(result_A.buffer, 0, i);
  }
  static ByteData _int32ToBytes(int value_A) => _toVarint32(value_A & 0xffffffff);
  static _makeWriteFunctionMap() {
    writeBytesNoTag(output, List<int> value_A) {
      output.writeInt32NoTag(value_A.length);
      output.writeRawBytes(new Uint8List(value_A.length)
          ..setRange(0, value_A.length, value_A));
    }
    makeWriter(convertor) => ((output, value_A) {
      output.writeRawBytes(convertor(value_A));
    });
    int _encodeZigZag32(int value_A) => (value_A << 1) ^ (value_A >> 31);
    Int64 _encodeZigZag64(Int64 value_A) => (value_A << 1) ^ (value_A >> 63);
    ByteData makeByteData32(int value_A) => new ByteData(4)
        ..setUint32(0, value_A, Endianness.LITTLE_ENDIAN);
    ByteData makeByteData64(Int64 value_A) {
      var data_A = new Uint8List.fromList(value_A.toBytes());
      return new ByteData.view(data_A.buffer, 0, 8);
    }
    return new Map<int, dynamic>()
        ..[PbFieldType._BOOL_BIT] = makeWriter((value_A) => _int32ToBytes(value_A ? 1 : 0))
        ..[PbFieldType._BYTES_BIT] = writeBytesNoTag
        ..[PbFieldType._STRING_BIT] = (output, value_A) {
      writeBytesNoTag(output, _UTF8.encode(value_A));
    }
        ..[PbFieldType._DOUBLE_BIT] = makeWriter((double value_A) {
      if (value_A.isNaN) return new ByteData(8)
          ..setUint32(0, 0x00000000, Endianness.LITTLE_ENDIAN)
          ..setUint32(4, 0x7ff80000, Endianness.LITTLE_ENDIAN);
      return new ByteData(8)
          ..setFloat64(0, value_A, Endianness.LITTLE_ENDIAN);
    })
        ..[PbFieldType._FLOAT_BIT] = makeWriter((double value_A) {
      const double MIN_FLOAT_DENORM = 1.401298464324817E-45;
      const double MAX_FLOAT = 3.4028234663852886E38;
      if (value_A.isNaN) return makeByteData32(0x7fc00000);
      if (value_A.abs() < MIN_FLOAT_DENORM) {
        return makeByteData32(value_A.isNegative ? 0x80000000 : 0x00000000);
      }
      if (value_A.isInfinite || value_A.abs() > MAX_FLOAT) {
        return makeByteData32(value_A.isNegative ? 0xff800000 : 0x7f800000);
      }
      return new ByteData(4)
          ..setFloat32(0, value_A, Endianness.LITTLE_ENDIAN);
    })
        ..[PbFieldType._ENUM_BIT] = makeWriter((value_A) => _int32ToBytes(value_A.value))
        ..[PbFieldType._GROUP_BIT] = (output, value_A) {
      value_A.writeToCodedBufferWriter(output);
    }
        ..[PbFieldType._INT32_BIT] = makeWriter(_int32ToBytes)
        ..[PbFieldType._INT64_BIT] = makeWriter((value_A) => _toVarint64(value_A))
        ..[PbFieldType._SINT32_BIT] = makeWriter((int value_A) => _int32ToBytes(_encodeZigZag32(value_A)))
        ..[PbFieldType._SINT64_BIT] = makeWriter((Int64 value_A) => _toVarint64(_encodeZigZag64(value_A)))
        ..[PbFieldType._UINT32_BIT] = makeWriter(_toVarint32)
        ..[PbFieldType._UINT64_BIT] = makeWriter(_toVarint64)
        ..[PbFieldType._FIXED32_BIT] = makeWriter(makeByteData32)
        ..[PbFieldType._FIXED64_BIT] = makeWriter(makeByteData64)
        ..[PbFieldType._SFIXED32_BIT] = makeWriter(makeByteData32)
        ..[PbFieldType._SFIXED64_BIT] = makeWriter(makeByteData64)
        ..[PbFieldType._MESSAGE_BIT] = (output, value_A) {
      output._withDeferredSizeCalculation(() {
        value_A.writeToCodedBufferWriter(output);
      });
    };
  }
  static final _OPEN_TAG_MAP = _makeOpenTagMap();
  static _makeOpenTagMap() {
    return new Map<int, int>()
        ..[PbFieldType._BOOL_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._BYTES_BIT] = WIRETYPE_LENGTH_DELIMITED
        ..[PbFieldType._STRING_BIT] = WIRETYPE_LENGTH_DELIMITED
        ..[PbFieldType._DOUBLE_BIT] = WIRETYPE_FIXED64
        ..[PbFieldType._FLOAT_BIT] = WIRETYPE_FIXED32
        ..[PbFieldType._ENUM_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._GROUP_BIT] = WIRETYPE_START_GROUP
        ..[PbFieldType._INT32_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._INT64_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._SINT32_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._SINT64_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._UINT32_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._UINT64_BIT] = WIRETYPE_VARINT
        ..[PbFieldType._FIXED32_BIT] = WIRETYPE_FIXED32
        ..[PbFieldType._FIXED64_BIT] = WIRETYPE_FIXED64
        ..[PbFieldType._SFIXED32_BIT] = WIRETYPE_FIXED32
        ..[PbFieldType._SFIXED64_BIT] = WIRETYPE_FIXED64
        ..[PbFieldType._MESSAGE_BIT] = WIRETYPE_LENGTH_DELIMITED;
  }
  void _withDeferredSizeCalculation(continuation) {
    int index_A = _output.length;
    _output.add(null);
    int currentRunningSizeInBytes = _runningSizeInBytes;
    continuation();
    int writtenSizeInBytes = _runningSizeInBytes - currentRunningSizeInBytes;
    TypedData sizeMarker = _int32ToBytes(writtenSizeInBytes);
    _output[index_A] = sizeMarker;
    _runningSizeInBytes += sizeMarker.lengthInBytes;
  }
  void writeField(int fieldNumber, int fieldType, fieldValue) {
    var valueType = fieldType & ~0x07;
    var writeFunction = _WRITE_FUNCTION_MAP[valueType];
    writeTag(int wireFormat) {
      writeInt32NoTag(makeTag(fieldNumber, wireFormat));
    }
    if ((fieldType & PbFieldType._PACKED_BIT) != 0) {
      if (!fieldValue.isEmpty) {
        writeTag(WIRETYPE_LENGTH_DELIMITED);
        _withDeferredSizeCalculation(() {
          for (var value_A in fieldValue) {
            writeFunction(this, value_A);
          }
        });
      }
      return;
    }
    writeValue(value_A) {
      writeTag(_OPEN_TAG_MAP[valueType]);
      writeFunction(this, value_A);
      if (valueType == PbFieldType._GROUP_BIT) {
        writeTag(WIRETYPE_END_GROUP);
      }
    }
    if ((fieldType & PbFieldType._REPEATED_BIT) != 0) {
      fieldValue.forEach(writeValue);
      return;
    }
    writeValue(fieldValue);
  }
  void writeInt32NoTag(int value_A) {
    writeRawBytes(_int32ToBytes(value_A));
  }
  void writeRawBytes(TypedData value_A) {
    _output.add(value_A);
    _runningSizeInBytes += value_A.lengthInBytes;
  }
  Uint8List toBuffer() {
    Uint8List result_A = new Uint8List(_runningSizeInBytes);
    int position_A = 0;
    for (var typedData in _output) {
      Uint8List asBytes = new Uint8List.view(typedData.buffer, typedData.offsetInBytes, typedData.lengthInBytes);
      result_A.setRange(position_A, position_A + typedData.lengthInBytes, asBytes);
      position_A += typedData.lengthInBytes;
    }
    return result_A;
  }
}
abstract class EventPlugin {}
class InvalidProtocolBufferException implements Exception {
  final String message;
  InvalidProtocolBufferException.__G(this.message);
  String toString() => 'InvalidProtocolBufferException: ${message}';
  InvalidProtocolBufferException.invalidEndTag() : this.__G('Protocol message end-group tag did not match expected tag.');
  InvalidProtocolBufferException.invalidTag() : this.__G('Protocol message contained an invalid tag (zero).');
  InvalidProtocolBufferException.invalidWireType() : this.__G('Protocol message tag had invalid wire type.');
  InvalidProtocolBufferException.malformedVarint() : this.__G('CodedBufferReader encountered a malformed varint.');
  InvalidProtocolBufferException.recursionLimitExceeded() : this.__G('''
Protocol message had too many levels of nesting.  May be malicious.
Use CodedBufferReader.setRecursionLimit() to increase the depth limit.
''');
  InvalidProtocolBufferException.truncatedMessage() : this.__G('''
While parsing a protocol message, the input ended unexpectedly
in the middle of a field.  This could mean either than the
input has been truncated or that an embedded message
misreported its own length.
''');
}
class Extension extends FieldInfo {
  final String extendee;
  Extension(this.extendee, String name_A, int tagNumber, int fieldType, [dynamic defaultOrMaker, CreateBuilderFunc subBuilder, ValueOfFunc valueOf_D]) : super(name_A, tagNumber, null, fieldType, defaultOrMaker, subBuilder, valueOf_D);
  int get hashCode => extendee.hashCode * 31 + tagNumber;
  bool operator==(other) {
    if (other is! Extension) return false;
    Extension o = other;
    return extendee == o.extendee && tagNumber == o.tagNumber;
  }
}
class _ExtensionFieldSet {
  final _FieldSet _parent;
  final Map<int, Extension> _info = <int, Extension>{};
  final Map<int, dynamic> _values_A = <int, dynamic>{};
  _ExtensionFieldSet(this._parent) {
    assert(!_parent._isReadOnly);
  }
  Extension _getInfoOrNull(int tagNumber) => _info[tagNumber];
  _getFieldOrDefault(Extension fi) {
    if (fi.isRepeated) return _ensureRepeatedField(fi);
    _validateInfo(fi);
    _addInfoUnchecked(fi);
    var value_A = _getFieldOrNull(fi);
    if (value_A == null) return fi.makeDefault();
    return value_A;
  }
  bool _hasField(int tagNumber) {
    var value_A = _values_A[tagNumber];
    if (value_A == null) return false;
    if (value_A is List) return value_A.isNotEmpty;
    return true;
  }
  List _ensureRepeatedField(Extension fi) {
    assert(fi.isRepeated);
    assert(fi.extendee == _parent._messageName);
    var list_A = _values_A[fi.tagNumber];
    if (list_A != null) return list_A;
    _validateInfo(fi);
    list_A = _parent._message.createRepeatedField(fi.tagNumber, fi);
    _addInfoUnchecked(fi);
    _setFieldUnchecked(fi, list_A);
    return list_A;
  }
  _getFieldOrNull(Extension extension) => _values_A[extension.tagNumber];
  void _setField(int tagNumber, value_A) {
    var fi = _getInfoOrNull(tagNumber);
    if (fi == null) {
      throw new ArgumentError("tag ${tagNumber} not defined in ${_parent}._messageName");
    }
    if (fi.isRepeated) {
      throw new ArgumentError(_parent._setFieldFailedMessage(fi, value_A, 'repeating field (use get + .add())'));
    }
    _parent._validateField_A(fi, value_A);
    _setFieldUnchecked(fi, value_A);
  }
  void _setFieldAndInfo(Extension fi, value_A) {
    if (fi.isRepeated) {
      throw new ArgumentError(_parent._setFieldFailedMessage(fi, value_A, 'repeating field (use get + .add())'));
    }
    _validateInfo(fi);
    _parent._validateField_A(fi, value_A);
    _addInfoUnchecked(fi);
    _setFieldUnchecked(fi, value_A);
  }
  void _validateInfo(Extension fi) {
    if (fi.extendee != _parent._messageName) {
      throw new ArgumentError('Extension ${fi} not legal for message ${_parent._messageName}');
    }
  }
  void _addInfoUnchecked(Extension fi) {
    assert(fi.extendee == _parent._messageName);
    _info[fi.tagNumber] = fi;
  }
  void _setFieldUnchecked(Extension fi, value_A) {
    if (_parent._hasObservers) {
      _parent._eventPlugin.beforeSetField(fi, value_A);
    }
    _values_A[fi.tagNumber] = value_A;
  }
  Iterable<int> get _tagNumbers => _values_A.keys;
  Iterable<Extension> get _infos => _info.values;
  get _hasValues => _values_A.isNotEmpty;
  bool _equalValues(_ExtensionFieldSet other) => _areMapsEqual(_values_A, other._values_A);
  void _clearValues() => _values_A.clear();
}
class ExtensionRegistry {
  final Map<String, Map<int, Extension>> _extensions = <String, Map<int, Extension>>{};
  static const ExtensionRegistry EMPTY = const _EmptyExtensionRegistry();
  void add(Extension extension) {
    var map_A = _extensions.putIfAbsent(extension.extendee, () => new Map<int, Extension>());
    map_A[extension.tagNumber] = extension;
  }
  Extension getExtension(String messageName, int tagNumber) {
    var map_A = _extensions[messageName];
    if (map_A != null) {
      return map_A[tagNumber];
    }
    return null;
  }
}
class _EmptyExtensionRegistry implements ExtensionRegistry {
  const _EmptyExtensionRegistry();
  get _extensions => null;
  void add(Extension extension) {
    throw new UnsupportedError('Immutable ExtensionRegistry');
  }
  Extension getExtension(String messageName, int tagNumber) => null;
}
String _getFieldError(int fieldType, var value_A) {
  switch (PbFieldType._baseType(fieldType)) {
    case PbFieldType._BOOL_BIT:
      if (value_A is! bool) return 'not type bool';
      return null;

    case PbFieldType._BYTES_BIT:
      if (value_A is! List) return 'not List';
      return null;

    case PbFieldType._STRING_BIT:
      if (value_A is! String) return 'not type String';
      return null;

    case PbFieldType._FLOAT_BIT:
      if (value_A is! double) return 'not type double';
      if (!_isFloat32(value_A)) return 'out of range for float';
      return null;

    case PbFieldType._DOUBLE_BIT:
      if (value_A is! double) return 'not type double';
      return null;

    case PbFieldType._ENUM_BIT:
      if (value_A is! ProtobufEnum) return 'not type ProtobufEnum';
      return null;

    case PbFieldType._INT32_BIT: case PbFieldType._SINT32_BIT: case PbFieldType._SFIXED32_BIT:
      if (value_A is! int) return 'not type int';
      if (!_isSigned32(value_A)) return 'out of range for signed 32-bit int';
      return null;

    case PbFieldType._UINT32_BIT: case PbFieldType._FIXED32_BIT:
      if (value_A is! int) return 'not type int';
      if (!_isUnsigned32(value_A)) return 'out of range for unsigned 32-bit int';
      return null;

    case PbFieldType._INT64_BIT: case PbFieldType._SINT64_BIT: case PbFieldType._UINT64_BIT: case PbFieldType._FIXED64_BIT: case PbFieldType._SFIXED64_BIT:
      if (value_A is! Int64) return 'not Int64';
      return null;

    case PbFieldType._GROUP_BIT: case PbFieldType._MESSAGE_BIT:
      if (value_A is! GeneratedMessage) return 'not a GeneratedMessage';
      return null;

    default:
      return 'field has unknown type ${fieldType}';
  }
}
void checkItemFailed(val, String className) {
  throw new ArgumentError('Value (${val}) is not an instance of ${className}');
}
CheckFunc getCheckFunction(int fieldType) {
  switch (fieldType & ~0x7) {
    case PbFieldType._BOOL_BIT:
      return _checkBool;

    case PbFieldType._BYTES_BIT:
      return _checkBytes;

    case PbFieldType._STRING_BIT:
      return _checkString;

    case PbFieldType._FLOAT_BIT:
      return _checkFloat;

    case PbFieldType._DOUBLE_BIT:
      return _checkDouble;

    case PbFieldType._INT32_BIT: case PbFieldType._SINT32_BIT: case PbFieldType._SFIXED32_BIT:
      return _checkSigned32;

    case PbFieldType._UINT32_BIT: case PbFieldType._FIXED32_BIT:
      return _checkUnsigned32;

    case PbFieldType._INT64_BIT: case PbFieldType._SINT64_BIT: case PbFieldType._SFIXED64_BIT: case PbFieldType._UINT64_BIT: case PbFieldType._FIXED64_BIT:
      return _checkAnyInt64;

    case PbFieldType._ENUM_BIT:
      return _checkAnyEnum;

    case PbFieldType._GROUP_BIT: case PbFieldType._MESSAGE_BIT:
      return _checkAnyMessage;
  }
  throw new ArgumentError('check function not implemented: ${fieldType}');
}
void _checkNotNull(val) {
  if (val == null) {
    throw new ArgumentError("Can't add a null to a repeated field");
  }
}
void _checkBool(bool val) {
  if (val is! bool) throw _createFieldTypeError(val, 'a bool');
}
void _checkBytes(List<int> val) {
  if (val is! List<int>) throw _createFieldTypeError(val, 'a List<int>');
}
void _checkString(String val) {
  if (val is! String) throw _createFieldTypeError(val, 'a String');
}
void _checkFloat(double val) {
  _checkDouble(val);
  if (!_isFloat32(val)) throw _createFieldRangeError(val, 'a float');
}
void _checkDouble(double val) {
  if (val is! double) throw _createFieldTypeError(val, 'a double');
}
void _checkInt(int val) {
  if (val is! int) throw _createFieldTypeError(val, 'an int');
}
void _checkSigned32(int val) {
  _checkInt(val);
  if (!_isSigned32(val)) throw _createFieldRangeError(val, 'a signed int32');
}
void _checkUnsigned32(int val) {
  _checkInt(val);
  if (!_isUnsigned32(val)) {
    throw _createFieldRangeError(val, 'an unsigned int32');
  }
}
void _checkAnyInt64(Int64 val) {
  if (val is! Int64) throw _createFieldTypeError(val, 'an Int64');
}
_checkAnyEnum(ProtobufEnum val) {
  if (val is! ProtobufEnum) throw _createFieldTypeError(val, 'a ProtobufEnum');
}
_checkAnyMessage(GeneratedMessage val) {
  if (val is! GeneratedMessage) {
    throw _createFieldTypeError(val, 'a GeneratedMessage');
  }
}
ArgumentError _createFieldTypeError(val, String wantedType) => new ArgumentError('Value (${val}) is not ${wantedType}');
RangeError _createFieldRangeError(val, String wantedType) => new RangeError('Value (${val}) is not ${wantedType}');
bool _inRange(min_A, value_A, max_A) => (min_A <= value_A) && (value_A <= max_A);
bool _isSigned32(int value_A) => _inRange(-2147483648, value_A, 2147483647);
bool _isUnsigned32(int value_A) => _inRange(0, value_A, 4294967295);
bool _isFloat32(double value_A) => value_A.isNaN || value_A.isInfinite || _inRange(-3.4028234663852886E38, value_A, 3.4028234663852886E38);
class FieldInfo {
  final String name;
  final int tagNumber;
  final int index;
  final int type;
  final MakeDefaultFunc makeDefault;
  final CreateBuilderFunc subBuilder;
  final ValueOfFunc valueOf_D;
  final CheckFunc check;
  FieldInfo(this.name, this.tagNumber, this.index, int type_A, [dynamic defaultOrMaker, this.subBuilder, this.valueOf_D]) : this.type = type_A, this.makeDefault = findMakeDefault(type_A, defaultOrMaker), this.check = null {
    assert(type_A != 0);
    assert(!_isGroupOrMessage(type_A) || subBuilder != null);
    assert(!_isEnum(type_A) || valueOf_D != null);
  }
  FieldInfo.repeated(this.name, this.tagNumber, this.index, int type_A, CheckFunc check_A, this.subBuilder, [this.valueOf_D]) : this.type = type_A, this.check = check_A, this.makeDefault = (() => new PbList(check: check_A)) {
    assert(name != null);
    assert(tagNumber != null);
    assert(_isRepeated(type_A));
    assert(check_A != null);
    assert(!_isEnum(type_A) || valueOf_D != null);
  }
  static MakeDefaultFunc findMakeDefault(int type_A, dynamic defaultOrMaker) {
    if (defaultOrMaker == null) return PbFieldType._defaultForType(type_A);
    if (defaultOrMaker is MakeDefaultFunc) return defaultOrMaker;
    return () => defaultOrMaker;
  }
  bool get isRequired => _isRequired(type);
  bool get isRepeated => _isRepeated(type);
  get readonlyDefault {
    if (isRepeated) return _emptyList;
    return makeDefault();
  }
  bool _hasRequiredValues(value_A) {
    if (value_A == null) return !isRequired;
    if (!_isGroupOrMessage(type)) return true;
    if (!isRepeated) {
      GeneratedMessage message_A = value_A;
      return message_A._fieldSet._hasRequiredValues();
    }
    List list_A = value_A;
    if (list_A.isEmpty) return true;
    if (!list_A[0]._fieldSet._hasRequiredFields) return true;
    return list_A.every((GeneratedMessage m) => m._fieldSet._hasRequiredValues());
  }
  void _appendInvalidFields(List<String> problems, value_A, String prefix) {
    if (value_A == null) {
      if (isRequired) problems.add('${prefix}${name}');
    } else if (!_isGroupOrMessage(type)) {} else if (!isRepeated) {
      GeneratedMessage message_A = value_A;
      message_A._fieldSet._appendInvalidFields(problems, '${prefix}${name}.');
    } else {
      List list_A = value_A;
      if (list_A.isEmpty) return;
      if (!list_A[0]._fieldSet._hasRequiredFields) return;
      int position_A = 0;
      for (GeneratedMessage message_A in list_A) {
        message_A._fieldSet._appendInvalidFields(problems, '${prefix}${name}[${position_A}].');
        position_A++;
      }
    }
  }
  String toString() => name;
}
final _emptyList = new List.unmodifiable([]);
class _FieldSet {
  final GeneratedMessage _message;
  final BuilderInfo _meta;
  final EventPlugin _eventPlugin;
  final List _values_A;
  _ExtensionFieldSet _extensions;
  UnknownFieldSet _unknownFields;
  _FieldSet(this._message, BuilderInfo meta, this._eventPlugin) : this._meta = meta, _values_A = _makeValueList(meta.fieldInfo);
  static _makeValueList(Map<int, FieldInfo> infos) {
    if (infos.isEmpty) return _emptyList;
    return new List(infos.length);
  }
  String get _messageName => _meta.messageName;
  bool get _isReadOnly => _message._isReadOnly;
  bool get _hasRequiredFields => _meta.hasRequiredFields;
  Iterable<FieldInfo> get _infos => _meta.fieldInfo.values;
  Iterable<FieldInfo> get _infosSortedByTag => _meta.sortedByTag;
  bool get _hasObservers => _eventPlugin != null && _eventPlugin.hasObservers;
  bool get _hasExtensions => _extensions != null;
  bool get hasUnknownFields => _unknownFields != null;
  _ExtensionFieldSet _ensureExtensions() {
    assert(!_isReadOnly);
    if (!_hasExtensions) _extensions = new _ExtensionFieldSet(this);
    return _extensions;
  }
  UnknownFieldSet _ensureUnknownFields() {
    if (_isReadOnly) return _ReadonlyUnknownFieldSet._empty_A;
    if (_unknownFields == null) _unknownFields = new UnknownFieldSet();
    return _unknownFields;
  }
  FieldInfo _nonExtensionInfo(int tagNumber) => _meta.fieldInfo[tagNumber];
  _getField(int tagNumber) {
    var fi = _nonExtensionInfo(tagNumber);
    if (fi != null) {
      var value_A = _values_A[fi.index];
      if (value_A != null) return value_A;
      return _getDefault(fi);
    }
    if (_hasExtensions) {
      var fi = _extensions._getInfoOrNull(tagNumber);
      if (fi != null) {
        return _extensions._getFieldOrDefault(fi);
      }
    }
    throw new ArgumentError("tag ${tagNumber} not defined in ${_messageName}");
  }
  _getDefault(FieldInfo fi) {
    if (!fi.isRepeated) return fi.makeDefault();
    if (_isReadOnly) return _emptyList;
    var value_A = _message.createRepeatedField(fi.tagNumber, fi);
    _setNonExtensionFieldUnchecked(fi, value_A);
    return value_A;
  }
  _getFieldOrNull(FieldInfo fi) {
    if (fi.index != null) return _values_A[fi.index];
    if (!_hasExtensions) return null;
    return _extensions._getFieldOrNull(fi);
  }
  bool _hasField(int tagNumber) {
    var fi = _nonExtensionInfo(tagNumber);
    if (fi != null) return _$has(fi.index, tagNumber);
    if (!_hasExtensions) return false;
    return _extensions._hasField(tagNumber);
  }
  void _setField(int tagNumber, value_A) {
    if (value_A == null) throw new ArgumentError('value is null');
    var fi = _nonExtensionInfo(tagNumber);
    if (fi == null) {
      if (!_hasExtensions) {
        throw new ArgumentError("tag ${tagNumber} not defined in ${_messageName}");
      }
      _extensions._setField(tagNumber, value_A);
      return;
    }
    if (fi.isRepeated) {
      throw new ArgumentError(_setFieldFailedMessage(fi, value_A, 'repeating field (use get + .add())'));
    }
    _validateField_A(fi, value_A);
    _setNonExtensionFieldUnchecked(fi, value_A);
  }
  void _setFieldUnchecked(FieldInfo fi, value_A) {
    assert(fi != null);
    assert(!fi.isRepeated);
    if (fi.index == null) {
      _ensureExtensions()
          .._addInfoUnchecked(fi)
          .._setFieldUnchecked(fi, value_A);
    } else {
      _setNonExtensionFieldUnchecked(fi, value_A);
    }
  }
  List _ensureRepeatedField(FieldInfo fi) {
    assert(!_isReadOnly);
    assert(fi.isRepeated);
    if (fi.index == null) {
      return _ensureExtensions()._ensureRepeatedField(fi);
    }
    var value_A = _getFieldOrNull(fi);
    if (value_A != null) return value_A;
    value_A = _message.createRepeatedField(fi.tagNumber, fi);
    _setNonExtensionFieldUnchecked(fi, value_A);
    return value_A;
  }
  void _setNonExtensionFieldUnchecked(FieldInfo fi, value_A) {
    if (_hasObservers) {
      _eventPlugin.beforeSetField(fi, value_A);
    }
    _values_A[fi.index] = value_A;
  }
  bool _$has(int index_A, int tagNumber) {
    assert(_nonExtensionInfo(tagNumber).index == index_A);
    var value_A = _values_A[index_A];
    if (value_A == null) return false;
    if (value_A is List) return value_A.isNotEmpty;
    return true;
  }
  void _clear_A() {
    if (_unknownFields != null) {
      _unknownFields.clear();
    }
    if (_hasObservers) {
      for (var fi in _infos) {
        if (_values_A[fi.index] != null) {
          _eventPlugin.beforeClearField(fi);
        }
      }
      if (_hasExtensions) {
        for (int key_A in _extensions._tagNumbers) {
          var fi = _extensions._getInfoOrNull(key_A);
          _eventPlugin.beforeClearField(fi);
        }
      }
    }
    if (_values_A.isNotEmpty) _values_A.fillRange(0, _values_A.length, null);
    if (_hasExtensions) _extensions._clearValues();
  }
  bool _equals_A(_FieldSet o) {
    if (_meta != o._meta) return false;
    if (!_areListsEqual(_values_A, o._values_A)) return false;
    if (!_hasExtensions || !_extensions._hasValues) {
      if (o._hasExtensions && o._extensions._hasValues) {
        return false;
      }
    } else {
      if (!_extensions._equalValues(o._extensions)) return false;
    }
    if (_unknownFields == null || _unknownFields.isEmpty) {
      if (o._unknownFields != null && o._unknownFields.isNotEmpty) return false;
    } else {
      if (_unknownFields != o._unknownFields) return false;
    }
    return true;
  }
  int get _hashCode {
    int hash;
    void hashEnumList(PbList enums) {
      enums.forEach((ProtobufEnum enm) {
        hash = (31 * hash + enm.value) & 0x3fffffff;
      });
    }
    void hashField(FieldInfo fi, value_A) {
      if (value_A is List && value_A.isEmpty) {
        return;
      }
      hash = ((37 * hash) + fi.tagNumber) & 0x3fffffff;
      if (!_isEnum(fi.type)) {
        hash = ((53 * hash) + (value_A as Object).hashCode) & 0x3fffffff;
      } else if (fi.isRepeated) {
        hashEnumList(value_A);
      } else {
        ProtobufEnum enm = value_A;
        hash = ((53 * hash) + enm.value) & 0x3fffffff;
      }
    }
    void hashEachField() {
      for (var fi in _infosSortedByTag) {
        var v = _values_A[fi.index];
        if (v != null) hashField(fi, v);
      }
      if (!_hasExtensions) return;
      for (int tagNumber in sorted(_extensions._tagNumbers)) {
        var fi = _extensions._getInfoOrNull(tagNumber);
        hashField(fi, _extensions._getFieldOrNull(fi));
      }
    }
    hash = 41;
    hash = ((19 * hash) + _meta.hashCode) & 0x3fffffff;
    hashEachField();
    if (hasUnknownFields) {
      hash = ((29 * hash) + _unknownFields.hashCode) & 0x3fffffff;
    }
    return hash;
  }
  void writeString(StringBuffer out, String indent_A) {
    void renderValue(key_A, value_A) {
      if (value_A is GeneratedMessage) {
        out.write('${indent_A}${key_A}: {\n');
        value_A._fieldSet.writeString(out, '${indent_A}  ');
        out.write('${indent_A}}\n');
      } else {
        out.write('${indent_A}${key_A}: ${value_A}\n');
      }
    }
    for (FieldInfo fi in _infosSortedByTag) {
      var fieldValue = _values_A[fi.index];
      if (fieldValue == null) continue;
      if (fieldValue is ByteData) {
        final value_A = fieldValue.getUint64(0, Endianness.LITTLE_ENDIAN);
        renderValue(fi.name, value_A);
      } else if (fieldValue is List) {
        for (var value_A in fieldValue) {
          renderValue(fi.name, value_A);
        }
      } else {
        renderValue(fi.name, fieldValue);
      }
    }
    if (hasUnknownFields) {
      out.write(_unknownFields.toString());
    } else {
      out.write(new UnknownFieldSet().toString());
    }
  }
  void _mergeFromMessage(_FieldSet other) {
    void mergeField(FieldInfo otherFi, fieldValue) {
      int tagNumber = otherFi.tagNumber;
      var fi = _nonExtensionInfo(tagNumber);
      if (fi == null && otherFi is Extension) {
        fi = otherFi;
      }
      var cloner = (x_A) => x_A;
      if (_isGroupOrMessage(otherFi.type)) {
        cloner = (message_A) => message_A.clone();
      }
      if (fi.isRepeated) {
        _ensureRepeatedField(fi).addAll(new List.from(fieldValue).map(cloner));
        return;
      }
      fieldValue = cloner(fieldValue);
      if (fi.index == null) {
        _ensureExtensions()._setFieldAndInfo(fi, fieldValue);
      } else {
        _validateField_A(fi, fieldValue);
        _setNonExtensionFieldUnchecked(fi, fieldValue);
      }
    }
    for (var fi in other._infos) {
      var value_A = other._values_A[fi.index];
      if (value_A != null) mergeField(fi, value_A);
    }
    if (other._hasExtensions) {
      var others = other._extensions;
      for (int tagNumber in others._tagNumbers) {
        var extension = others._getInfoOrNull(tagNumber);
        var value_A = others._getFieldOrNull(extension);
        mergeField(extension, value_A);
      }
    }
    if (other.hasUnknownFields) {
      _ensureUnknownFields().mergeFromUnknownFieldSet(other._unknownFields);
    }
  }
  void _validateField_A(FieldInfo fi, var newValue) {
    var message_A = _getFieldError(fi.type, newValue);
    if (message_A != null) {
      throw new ArgumentError(_setFieldFailedMessage(fi, newValue, message_A));
    }
  }
  String _setFieldFailedMessage(FieldInfo fi, var value_A, String detail) {
    return 'Illegal to set field ${fi.name} (${fi.tagNumber}) of ${_messageName}' ' to value (${value_A}): ${detail}';
  }
  bool _hasRequiredValues() {
    if (!_hasRequiredFields) return true;
    for (var fi in _infos) {
      var value_A = _values_A[fi.index];
      if (!fi._hasRequiredValues(value_A)) return false;
    }
    return _hasRequiredExtensionValues();
  }
  bool _hasRequiredExtensionValues() {
    if (!_hasExtensions) return true;
    for (var fi in _extensions._infos) {
      var value_A = _extensions._getFieldOrNull(fi);
      if (!fi._hasRequiredValues(value_A)) return false;
    }
    return true;
  }
  void _appendInvalidFields(List<String> problems, String prefix) {
    if (!_hasRequiredFields) return;
    for (var fi in _infos) {
      var value_A = _values_A[fi.index];
      fi._appendInvalidFields(problems, value_A, prefix);
    }
  }
}
bool _isRepeated(int fieldType) => (fieldType & PbFieldType._REPEATED_BIT) != 0;
bool _isRequired(int fieldType) => (fieldType & PbFieldType._REQUIRED_BIT) != 0;
bool _isEnum(int fieldType) => PbFieldType._baseType(fieldType) == PbFieldType._ENUM_BIT;
bool _isGroupOrMessage(int fieldType) => (fieldType & (PbFieldType._GROUP_BIT | PbFieldType._MESSAGE_BIT)) != 0;
class PbFieldType {
  static int _baseType(int fieldType) => fieldType & ~(_REQUIRED_BIT | _REPEATED_BIT | _PACKED_BIT);
  static MakeDefaultFunc _defaultForType(int type_A) {
    switch (type_A) {
      case _OPTIONAL_BOOL: case _REQUIRED_BOOL:
        return _BOOL_FALSE;

      case _OPTIONAL_BYTES: case _REQUIRED_BYTES:
        return _BYTES_EMPTY;

      case _OPTIONAL_STRING: case _REQUIRED_STRING:
        return _STRING_EMPTY;

      case _OPTIONAL_FLOAT: case _REQUIRED_FLOAT: case _OPTIONAL_DOUBLE: case _REQUIRED_DOUBLE:
        return _DOUBLE_ZERO;

      case _OPTIONAL_INT32: case _REQUIRED_INT32: case _OPTIONAL_INT64: case _REQUIRED_INT64: case _OPTIONAL_SINT32: case _REQUIRED_SINT32: case _OPTIONAL_SINT64: case _REQUIRED_SINT64: case _OPTIONAL_UINT32: case _REQUIRED_UINT32: case _OPTIONAL_UINT64: case _REQUIRED_UINT64: case _OPTIONAL_FIXED32: case _REQUIRED_FIXED32: case _OPTIONAL_FIXED64: case _REQUIRED_FIXED64: case _OPTIONAL_SFIXED32: case _REQUIRED_SFIXED32: case _OPTIONAL_SFIXED64: case _REQUIRED_SFIXED64:
        return _INT_ZERO;

      default:
        return null;
    }
  }
  static String _STRING_EMPTY() => '';
  static List<int> _BYTES_EMPTY() => new PbList(check: _checkInt);
  static bool _BOOL_FALSE() => false;
  static int _INT_ZERO() => 0;
  static double _DOUBLE_ZERO() => 0.0;
  static const int _REQUIRED_BIT = 0x1;
  static const int _REPEATED_BIT = 0x2;
  static const int _PACKED_BIT = 0x4;
  static const int _BOOL_BIT = 0x10;
  static const int _BYTES_BIT = 0x20;
  static const int _STRING_BIT = 0x40;
  static const int _DOUBLE_BIT = 0x80;
  static const int _FLOAT_BIT = 0x100;
  static const int _ENUM_BIT = 0x200;
  static const int _GROUP_BIT = 0x400;
  static const int _INT32_BIT = 0x800;
  static const int _INT64_BIT = 0x1000;
  static const int _SINT32_BIT = 0x2000;
  static const int _SINT64_BIT = 0x4000;
  static const int _UINT32_BIT = 0x8000;
  static const int _UINT64_BIT = 0x10000;
  static const int _FIXED32_BIT = 0x20000;
  static const int _FIXED64_BIT = 0x40000;
  static const int _SFIXED32_BIT = 0x80000;
  static const int _SFIXED64_BIT = 0x100000;
  static const int _MESSAGE_BIT = 0x200000;
  static const int _OPTIONAL_BOOL = _BOOL_BIT;
  static const int _OPTIONAL_BYTES = _BYTES_BIT;
  static const int _OPTIONAL_STRING = _STRING_BIT;
  static const int _OPTIONAL_FLOAT = _FLOAT_BIT;
  static const int _OPTIONAL_DOUBLE = _DOUBLE_BIT;
  static const int _OPTIONAL_ENUM = _ENUM_BIT;
  static const int _OPTIONAL_GROUP = _GROUP_BIT;
  static const int _OPTIONAL_INT32 = _INT32_BIT;
  static const int _OPTIONAL_INT64 = _INT64_BIT;
  static const int _OPTIONAL_SINT32 = _SINT32_BIT;
  static const int _OPTIONAL_SINT64 = _SINT64_BIT;
  static const int _OPTIONAL_UINT32 = _UINT32_BIT;
  static const int _OPTIONAL_UINT64 = _UINT64_BIT;
  static const int _OPTIONAL_FIXED32 = _FIXED32_BIT;
  static const int _OPTIONAL_FIXED64 = _FIXED64_BIT;
  static const int _OPTIONAL_SFIXED32 = _SFIXED32_BIT;
  static const int _OPTIONAL_SFIXED64 = _SFIXED64_BIT;
  static const int _OPTIONAL_MESSAGE = _MESSAGE_BIT;
  static const int _REQUIRED_BOOL = _REQUIRED_BIT | _BOOL_BIT;
  static const int _REQUIRED_BYTES = _REQUIRED_BIT | _BYTES_BIT;
  static const int _REQUIRED_STRING = _REQUIRED_BIT | _STRING_BIT;
  static const int _REQUIRED_FLOAT = _REQUIRED_BIT | _FLOAT_BIT;
  static const int _REQUIRED_DOUBLE = _REQUIRED_BIT | _DOUBLE_BIT;
  static const int _REQUIRED_INT32 = _REQUIRED_BIT | _INT32_BIT;
  static const int _REQUIRED_INT64 = _REQUIRED_BIT | _INT64_BIT;
  static const int _REQUIRED_SINT32 = _REQUIRED_BIT | _SINT32_BIT;
  static const int _REQUIRED_SINT64 = _REQUIRED_BIT | _SINT64_BIT;
  static const int _REQUIRED_UINT32 = _REQUIRED_BIT | _UINT32_BIT;
  static const int _REQUIRED_UINT64 = _REQUIRED_BIT | _UINT64_BIT;
  static const int _REQUIRED_FIXED32 = _REQUIRED_BIT | _FIXED32_BIT;
  static const int _REQUIRED_FIXED64 = _REQUIRED_BIT | _FIXED64_BIT;
  static const int _REQUIRED_SFIXED32 = _REQUIRED_BIT | _SFIXED32_BIT;
  static const int _REQUIRED_SFIXED64 = _REQUIRED_BIT | _SFIXED64_BIT;
  static const int _REPEATED_BOOL = _REPEATED_BIT | _BOOL_BIT;
  static const int _REPEATED_BYTES = _REPEATED_BIT | _BYTES_BIT;
  static const int _REPEATED_STRING = _REPEATED_BIT | _STRING_BIT;
  static const int _REPEATED_FLOAT = _REPEATED_BIT | _FLOAT_BIT;
  static const int _REPEATED_DOUBLE = _REPEATED_BIT | _DOUBLE_BIT;
  static const int _REPEATED_ENUM = _REPEATED_BIT | _ENUM_BIT;
  static const int _REPEATED_GROUP = _REPEATED_BIT | _GROUP_BIT;
  static const int _REPEATED_INT32 = _REPEATED_BIT | _INT32_BIT;
  static const int _REPEATED_INT64 = _REPEATED_BIT | _INT64_BIT;
  static const int _REPEATED_SINT32 = _REPEATED_BIT | _SINT32_BIT;
  static const int _REPEATED_SINT64 = _REPEATED_BIT | _SINT64_BIT;
  static const int _REPEATED_UINT32 = _REPEATED_BIT | _UINT32_BIT;
  static const int _REPEATED_UINT64 = _REPEATED_BIT | _UINT64_BIT;
  static const int _REPEATED_FIXED32 = _REPEATED_BIT | _FIXED32_BIT;
  static const int _REPEATED_FIXED64 = _REPEATED_BIT | _FIXED64_BIT;
  static const int _REPEATED_SFIXED32 = _REPEATED_BIT | _SFIXED32_BIT;
  static const int _REPEATED_SFIXED64 = _REPEATED_BIT | _SFIXED64_BIT;
  static const int _REPEATED_MESSAGE = _REPEATED_BIT | _MESSAGE_BIT;
  static const int _PACKED_INT32 = _REPEATED_BIT | _PACKED_BIT | _INT32_BIT;
  static const int OB = _OPTIONAL_BOOL;
  static const int OY = _OPTIONAL_BYTES;
  static const int OS = _OPTIONAL_STRING;
  static const int OD = _OPTIONAL_DOUBLE;
  static const int OE = _OPTIONAL_ENUM;
  static const int O3 = _OPTIONAL_INT32;
  static const int O6 = _OPTIONAL_INT64;
  static const int OU6 = _OPTIONAL_UINT64;
  static const int OM = _OPTIONAL_MESSAGE;
  static const int QB = _REQUIRED_BOOL;
  static const int QS = _REQUIRED_STRING;
  static const int PS = _REPEATED_STRING;
  static const int P3 = _REPEATED_INT32;
  static const int PM = _REPEATED_MESSAGE;
  static const int K3 = _PACKED_INT32;
}
typedef GeneratedMessage CreateBuilderFunc();
typedef Object MakeDefaultFunc();
typedef ProtobufEnum ValueOfFunc(int _0);
abstract class GeneratedMessage {
  _FieldSet _fieldSet;
  GeneratedMessage() {
    _fieldSet = new _FieldSet(this, info_, eventPlugin);
    if (eventPlugin != null) eventPlugin.attach(this);
  }
  GeneratedMessage.fromBuffer_A(List<int> input_A, ExtensionRegistry extensionRegistry) {
    _fieldSet = new _FieldSet(this, info_, eventPlugin);
    if (eventPlugin != null) eventPlugin.attach(this);
    mergeFromBuffer(input_A, extensionRegistry);
  }
  BuilderInfo get info_;
  EventPlugin get eventPlugin => null;
  bool get _isReadOnly => false;
  bool hasRequiredFields() => info_.hasRequiredFields;
  bool isInitialized() => _fieldSet._hasRequiredValues();
  void clear() => _fieldSet._clear_A();
  bool operator==(other) {
    if (other is! GeneratedMessage) return false;
    return _fieldSet._equals_A(other._fieldSet);
  }
  int get hashCode => _fieldSet._hashCode;
  String toString() {
    var out = new StringBuffer();
    _fieldSet.writeString(out, '');
    return out.toString();
  }
  void check() {
    if (!isInitialized()) {
      List<String> invalidFields = <String>[];
      _fieldSet._appendInvalidFields(invalidFields, "");
      String missingFields = (invalidFields
          ..sort()).join(', ');
      throw new StateError('Message missing required fields: ${missingFields}');
    }
  }
  Uint8List writeToBuffer() {
    CodedBufferWriter out = new CodedBufferWriter();
    writeToCodedBufferWriter(out);
    return out.toBuffer();
  }
  void writeToCodedBufferWriter(CodedBufferWriter output) => _writeToCodedBufferWriter(_fieldSet, output);
  void mergeFromCodedBufferReader(CodedBufferReader input_A, [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) => _mergeFromCodedBufferReader(_fieldSet, input_A, extensionRegistry);
  void mergeFromBuffer(List<int> input_A, [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) {
    CodedBufferReader codedInput = new CodedBufferReader(input_A);
    _mergeFromCodedBufferReader(_fieldSet, codedInput, extensionRegistry);
    codedInput.checkLastTagWas(0);
  }
  Map<String, dynamic> writeToJsonMap() => _writeToJsonMap(_fieldSet);
  getExtension(Extension extension) {
    if (_isReadOnly) return extension.readonlyDefault;
    return _fieldSet._ensureExtensions()._getFieldOrDefault(extension);
  }
  getField(int tagNumber) => _fieldSet._getField(tagNumber);
  List createRepeatedField(int tagNumber, FieldInfo fi) {
    if (fi.check != null) {
      return new PbList(check: fi.check);
    } else {
      return fi.makeDefault();
    }
  }
  bool hasExtension(Extension extension) => _fieldSet._hasExtensions && _fieldSet._extensions._getFieldOrNull(extension) != null;
  bool hasField(int tagNumber) => _fieldSet._hasField(tagNumber);
  void mergeFromMessage(GeneratedMessage other) => _fieldSet._mergeFromMessage(other._fieldSet);
  void setField(int tagNumber, value_A) => _fieldSet._setField(tagNumber, value_A);
}
Int64 _MAX_JSON_INT = new Int64.fromInts(0x200000, 0);
Int64 _MIN_JSON_INT = -_MAX_JSON_INT;
Map<String, dynamic> _writeToJsonMap(_FieldSet fs) {
  convertToMap(fieldValue, fieldType) {
    int baseType = PbFieldType._baseType(fieldType);
    if (_isRepeated(fieldType)) {
      return new List.from(fieldValue.map((e) => convertToMap(e, baseType)));
    }
    switch (baseType) {
      case PbFieldType._BOOL_BIT: case PbFieldType._STRING_BIT: case PbFieldType._FLOAT_BIT: case PbFieldType._DOUBLE_BIT: case PbFieldType._INT32_BIT: case PbFieldType._SINT32_BIT: case PbFieldType._UINT32_BIT: case PbFieldType._FIXED32_BIT: case PbFieldType._SFIXED32_BIT:
        return fieldValue;

      case PbFieldType._BYTES_BIT:
        return CryptoUtils.bytesToBase64_A(fieldValue);

      case PbFieldType._ENUM_BIT:
        return fieldValue.value;

      case PbFieldType._INT64_BIT: case PbFieldType._SINT64_BIT: case PbFieldType._UINT64_BIT: case PbFieldType._FIXED64_BIT: case PbFieldType._SFIXED64_BIT:
        if (_MIN_JSON_INT <= fieldValue && fieldValue <= _MAX_JSON_INT) {
          return fieldValue.toInt();
        }
        return fieldValue.toString();

      case PbFieldType._GROUP_BIT: case PbFieldType._MESSAGE_BIT:
        return fieldValue.writeToJsonMap();

      default:
        throw 'Unknown type ${fieldType}';
    }
  }
  var result_A = <String, dynamic>{};
  for (var fi in fs._infosSortedByTag) {
    var value_A = fs._values_A[fi.index];
    if (value_A == null || (value_A is List && value_A.isEmpty)) {
      continue;
    }
    result_A['${fi.tagNumber}'] = convertToMap(value_A, fi.type);
  }
  if (fs._hasExtensions) {
    for (int tagNumber in sorted(fs._extensions._tagNumbers)) {
      var value_A = fs._extensions._values_A[tagNumber];
      if (value_A is List && value_A.isEmpty) {
        continue;
      }
      var fi = fs._extensions._getInfoOrNull(tagNumber);
      result_A['${tagNumber}'] = convertToMap(value_A, fi.type);
    }
  }
  return result_A;
}
typedef dynamic CheckFunc(_0);
class PbList<E_A> extends Object with ListMixin<E_A> implements List<E_A> {
  final List<E_A> _wrappedList;
  final CheckFunc check;
  PbList({this.check: _checkNotNull}) : _wrappedList = <E_A>[] {
    assert(check != null);
  }
  bool operator==(other) => (other is PbList) && _areListsEqual(other, this);
  int get hashCode {
    int hash = 0;
    _wrappedList.forEach((E_A value_A) {
      hash = (hash + value_A.hashCode) & 0x3fffffff;
      hash = (hash + hash << 10) & 0x3fffffff;
      hash = (hash ^ hash >> 6) & 0x3fffffff;
    });
    hash = (hash + hash << 3) & 0x3fffffff;
    hash = (hash ^ hash >> 11) & 0x3fffffff;
    hash = (hash + hash << 15) & 0x3fffffff;
    return hash;
  }
  Iterator<E_A> get iterator => _wrappedList.iterator;
  E_A operator[](int index_A) => _wrappedList[index_A];
  void operator[]=(int index_A, E_A value_A) {
    _validate_A(value_A);
    _wrappedList[index_A] = value_A;
  }
  void set length(int newLength) {
    if (newLength > length) {
      throw new ArgumentError('Extending protobuf lists is not supported');
    }
    _wrappedList.length = newLength;
  }
  void add(E_A value_A) {
    _validate_A(value_A);
    _wrappedList.add(value_A);
  }
  void addAll(Iterable<E_A> collection) {
    collection.forEach(_validate_A);
    _wrappedList.addAll(collection);
  }
  void setRange(int start_A, int end_A, Iterable<E_A> from_A, [int skipCount = 0]) {
    from_A.skip(skipCount).take(end_A - start_A).forEach(_validate_A);
    _wrappedList.setRange(start_A, end_A, from_A, skipCount);
  }
  void insert(int index_A, E_A element_A) {
    _validate_A(element_A);
    _wrappedList.insert(index_A, element_A);
  }
  void insertAll(int index_A, Iterable<E_A> iterable) {
    iterable.forEach(_validate_A);
    _wrappedList.insertAll(index_A, iterable);
  }
  void setAll(int index_A, Iterable<E_A> iterable) {
    iterable.forEach(_validate_A);
    _wrappedList.setAll(index_A, iterable);
  }
  int get length => _wrappedList.length;
  void _validate_A(E_A val) {
    check(val);
    if (val is! E_A) {
      throw new ArgumentError('Value (${val}) is not of the correct type');
    }
  }
}
class ProtobufEnum {
  final int value;
  final String name;
  const ProtobufEnum(this.value, this.name);
  static Map<int, dynamic> initByValue(List<ProtobufEnum> byIndex) {
    var byValue = new Map<int, dynamic>();
    for (ProtobufEnum v in byIndex) {
      byValue[v.value] = v;
    }
    return byValue;
  }
  int get hashCode => value;
  String toString() => name;
}
abstract class ReadonlyMessageMixin {
  BuilderInfo get info_;
  get _isReadOnly => true;
  void clear() => _readonly("clear");
  createRepeatedField(int tagNumber, FieldInfo fi) => _readonly("createRepeatedField");
  void mergeFromBuffer(List<int> input_A, [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) => _readonly("mergeFromBuffer");
  void mergeFromCodedBufferReader(CodedBufferReader input_A, [ExtensionRegistry extensionRegistry = ExtensionRegistry.EMPTY]) => _readonly("mergeFromCodedBufferReader");
  void mergeFromMessage(GeneratedMessage other) => _readonly("mergeFromMessage");
  void setField(int tagNumber, var value_A, [int fieldType = null]) => _readonly("setField");
  void _readonly(String methodName) {
    String messageType_A = info_.messageName;
    throw new UnsupportedError("attempted to call ${methodName} on a read-only message (${messageType_A})");
  }
}
class _ReadonlyUnknownFieldSet extends UnknownFieldSet {
  static final _empty_A = new _ReadonlyUnknownFieldSet();
  void clear() => _readonly("clear");
  void mergeField(int number, UnknownFieldSetField field) => _readonly("mergeField");
  bool mergeFieldFromBuffer(int tag, CodedBufferReader input_A) {
    _readonly("mergeFieldFromBuffer");
    return false;
  }
  void mergeFromCodedBufferReader(CodedBufferReader input_A) => _readonly("mergeFromCodedBufferReader");
  void mergeFromUnknownFieldSet(UnknownFieldSet other) => _readonly("mergeFromUnknownFieldSet");
  UnknownFieldSetField _getField(int number) {
    _readonly("a merge method");
    return null;
  }
  void _readonly(String methodName) {
    throw new UnsupportedError("attempted to call ${methodName} on a read-only UnknownFieldSet");
  }
}
class UnknownFieldSet {
  final Map<int, UnknownFieldSetField> _fields = new Map<int, UnknownFieldSetField>();
  UnknownFieldSet();
  UnknownFieldSet._clone_A(UnknownFieldSet unknownFieldSet) {
    mergeFromUnknownFieldSet(unknownFieldSet);
  }
  UnknownFieldSet clone() => new UnknownFieldSet._clone_A(this);
  bool get isEmpty => _fields.isEmpty;
  bool get isNotEmpty => _fields.isNotEmpty;
  Map<int, UnknownFieldSetField> asMap() => new Map.from(_fields);
  void clear() {
    _fields.clear();
  }
  UnknownFieldSetField getField(int tagNumber) => _fields[tagNumber];
  bool hasField(int tagNumber) => _fields.containsKey(tagNumber);
  void mergeField(int number, UnknownFieldSetField field) {
    _getField(number)
        ..varints.addAll(field.varints)
        ..fixed32s.addAll(field.fixed32s)
        ..fixed64s.addAll(field.fixed64s)
        ..lengthDelimited.addAll(field.lengthDelimited)
        ..groups.addAll(field.groups);
  }
  bool mergeFieldFromBuffer(int tag, CodedBufferReader input_A) {
    int number = getTagFieldNumber(tag);
    switch (getTagWireType(tag)) {
      case WIRETYPE_VARINT:
        mergeVarintField(number, input_A.readInt64());
        return true;

      case WIRETYPE_FIXED64:
        mergeFixed64Field(number, input_A.readFixed64());
        return true;

      case WIRETYPE_LENGTH_DELIMITED:
        mergeLengthDelimitedField(number, input_A.readBytes());
        return true;

      case WIRETYPE_START_GROUP:
        UnknownFieldSet subGroup = input_A.readUnknownFieldSetGroup(number);
        mergeGroupField(number, subGroup);
        return true;

      case WIRETYPE_END_GROUP:
        return false;

      case WIRETYPE_FIXED32:
        mergeFixed32Field(number, input_A.readFixed32());
        return true;

      default:
        throw new InvalidProtocolBufferException.invalidWireType();
    }
  }
  void mergeFromCodedBufferReader(CodedBufferReader input_A) {
    while (true) {
      int tag = input_A.readTag();
      if (tag == 0 || !mergeFieldFromBuffer(tag, input_A)) {
        break;
      }
    }
  }
  void mergeFromUnknownFieldSet(UnknownFieldSet other) {
    for (int key_A in other._fields.keys) {
      mergeField(key_A, other._fields[key_A]);
    }
  }
  _checkFieldNumber(int number) {
    if (number == 0) {
      throw new ArgumentError('Zero is not a valid field number.');
    }
  }
  void mergeFixed32Field(int number, int value_A) {
    _getField(number).addFixed32(value_A);
  }
  void mergeFixed64Field(int number, Int64 value_A) {
    _getField(number).addFixed64(value_A);
  }
  void mergeGroupField(int number, UnknownFieldSet value_A) {
    _getField(number).addGroup(value_A);
  }
  void mergeLengthDelimitedField(int number, List<int> value_A) {
    _getField(number).addLengthDelimited(value_A);
  }
  void mergeVarintField(int number, Int64 value_A) {
    _getField(number).addVarint(value_A);
  }
  UnknownFieldSetField _getField(int number) {
    _checkFieldNumber(number);
    return _fields.putIfAbsent(number, () => new UnknownFieldSetField());
  }
  bool operator==(other) {
    if (other is! UnknownFieldSet) return false;
    UnknownFieldSet o = other;
    return _areMapsEqual(o._fields, _fields);
  }
  int get hashCode {
    int hash = 0;
    _fields.forEach((int number, Object value_A) {
      hash = ((37 * hash) + number) & 0x3fffffff;
      hash = ((53 * hash) + value_A.hashCode) & 0x3fffffff;
    });
    return hash;
  }
  String toString() => _toString_A('');
  String _toString_A(String indent_A) {
    var stringBuffer = new StringBuffer();
    for (int tag in sorted(_fields.keys)) {
      var field = _fields[tag];
      for (var value_A in field.values) {
        if (value_A is UnknownFieldSet) {
          stringBuffer
              ..write('${indent_A}${tag}: {\n')
              ..write(value_A._toString_A('${indent_A}  '))
              ..write('${indent_A}}\n');
        } else {
          if (value_A is ByteData) {
            value_A = value_A.getUint64(0, Endianness.LITTLE_ENDIAN);
          }
          stringBuffer.write('${indent_A}${tag}: ${value_A}\n');
        }
      }
    }
    return stringBuffer.toString();
  }
  void writeToCodedBufferWriter(CodedBufferWriter output) {
    for (int key_A in _fields.keys) {
      _fields[key_A].writeTo(key_A, output);
    }
  }
}
class UnknownFieldSetField {
  final List<List<int>> lengthDelimited = <List<int>>[];
  final List<Int64> varints = <Int64>[];
  final List<int> fixed32s = <int>[];
  final List<Int64> fixed64s = <Int64>[];
  final List<UnknownFieldSet> groups = <UnknownFieldSet>[];
  bool operator==(other) {
    if (other is! UnknownFieldSetField) return false;
    UnknownFieldSetField o = other;
    if (lengthDelimited.length != o.lengthDelimited.length) return false;
    for (int i = 0; i < lengthDelimited.length; i++) {
      if (!_areListsEqual(o.lengthDelimited[i], lengthDelimited[i])) {
        return false;
      }
    }
    if (!_areListsEqual(o.varints, varints)) return false;
    if (!_areListsEqual(o.fixed32s, fixed32s)) return false;
    if (!_areListsEqual(o.fixed64s, fixed64s)) return false;
    if (!_areListsEqual(o.groups, groups)) return false;
    return true;
  }
  int get hashCode {
    int hash = 0;
    lengthDelimited.forEach((List<int> value_A) {
      for (int i = 0; i < value_A.length; i++) {
        hash = (hash + value_A[i]) & 0x3fffffff;
        hash = (hash + hash << 10) & 0x3fffffff;
        hash = (hash ^ hash >> 6) & 0x3fffffff;
      }
      hash = (hash + hash << 3) & 0x3fffffff;
      hash = (hash ^ hash >> 11) & 0x3fffffff;
      hash = (hash + hash << 15) & 0x3fffffff;
    });
    varints.forEach((Object value_A) => hash = (hash + 7 * value_A.hashCode) & 0x3fffffff);
    fixed32s.forEach((Object value_A) => hash = (hash + 37 * value_A.hashCode) & 0x3fffffff);
    fixed64s.forEach((Object value_A) => hash = (hash + 53 * value_A.hashCode) & 0x3fffffff);
    groups.forEach((Object value_A) => hash = (hash + value_A.hashCode) & 0x3fffffff);
    return hash;
  }
  List get values => []
      ..addAll(lengthDelimited)
      ..addAll(varints)
      ..addAll(fixed32s)
      ..addAll(fixed64s)
      ..addAll(groups);
  void writeTo(int fieldNumber, CodedBufferWriter output) {
    write_A(type_A, value_A) {
      output.writeField(fieldNumber, type_A, value_A);
    }
    write_A(PbFieldType._REPEATED_UINT64, varints);
    write_A(PbFieldType._REPEATED_FIXED32, fixed32s);
    write_A(PbFieldType._REPEATED_FIXED64, fixed64s);
    write_A(PbFieldType._REPEATED_BYTES, lengthDelimited);
    write_A(PbFieldType._REPEATED_GROUP, groups);
  }
  void addGroup(UnknownFieldSet value_A) {
    groups.add(value_A);
  }
  void addLengthDelimited(List<int> value_A) {
    lengthDelimited.add(value_A);
  }
  void addFixed32(int value_A) {
    fixed32s.add(value_A);
  }
  void addFixed64(Int64 value_A) {
    fixed64s.add(value_A);
  }
  void addVarint(Int64 value_A) {
    varints.add(value_A);
  }
  bool hasRequiredFields() => false;
  bool isInitialized() => true;
  int get length => values.length;
}
bool _deepEquals(lhs, rhs) {
  if ((lhs is List) && (rhs is List)) return _areListsEqual(lhs, rhs);
  if ((lhs is Map) && (rhs is Map)) return _areMapsEqual(lhs, rhs);
  if ((lhs is ByteData) && (rhs is ByteData)) {
    return _areByteDataEqual(lhs, rhs);
  }
  return lhs == rhs;
}
bool _areListsEqual(List lhs, List rhs) {
  range_A(i) => new Iterable.generate(i, (i) => i);
  if (lhs.length != rhs.length) return false;
  return range_A(lhs.length).every((i) => _deepEquals(lhs[i], rhs[i]));
}
bool _areMapsEqual(Map lhs, Map rhs) {
  if (lhs.length != rhs.length) return false;
  return lhs.keys.every((key_A) => _deepEquals(lhs[key_A], rhs[key_A]));
}
bool _areByteDataEqual(ByteData lhs, ByteData rhs) {
  asBytes(d) => new Uint8List.view(d.buffer, d.offsetInBytes, d.lengthInBytes);
  return _areListsEqual(asBytes(lhs), asBytes(rhs));
}
List sorted(Iterable list_A) => new List.from(list_A)
    ..sort();
const int TAG_TYPE_BITS = 3;
const int TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1;
const int WIRETYPE_VARINT = 0;
const int WIRETYPE_FIXED64 = 1;
const int WIRETYPE_LENGTH_DELIMITED = 2;
const int WIRETYPE_START_GROUP = 3;
const int WIRETYPE_END_GROUP = 4;
const int WIRETYPE_FIXED32 = 5;
int getTagFieldNumber(int tag) => (tag & 0x7fffffff) >> TAG_TYPE_BITS;
int getTagWireType(int tag) => tag & TAG_TYPE_MASK;
int makeTag(int fieldNumber, int tag) => (fieldNumber << TAG_TYPE_BITS) | tag;
bool _wireTypeMatches(int fieldType, int wireType) {
  switch (PbFieldType._baseType(fieldType)) {
    case PbFieldType._BOOL_BIT: case PbFieldType._ENUM_BIT: case PbFieldType._INT32_BIT: case PbFieldType._INT64_BIT: case PbFieldType._SINT32_BIT: case PbFieldType._SINT64_BIT: case PbFieldType._UINT32_BIT: case PbFieldType._UINT64_BIT:
      return wireType == WIRETYPE_VARINT || wireType == WIRETYPE_LENGTH_DELIMITED;

    case PbFieldType._FLOAT_BIT: case PbFieldType._FIXED32_BIT: case PbFieldType._SFIXED32_BIT:
      return wireType == WIRETYPE_FIXED32 || wireType == WIRETYPE_LENGTH_DELIMITED;

    case PbFieldType._DOUBLE_BIT: case PbFieldType._FIXED64_BIT: case PbFieldType._SFIXED64_BIT:
      return wireType == WIRETYPE_FIXED64 || wireType == WIRETYPE_LENGTH_DELIMITED;

    case PbFieldType._BYTES_BIT: case PbFieldType._STRING_BIT: case PbFieldType._MESSAGE_BIT:
      return wireType == WIRETYPE_LENGTH_DELIMITED;

    case PbFieldType._GROUP_BIT:
      return wireType == WIRETYPE_START_GROUP;

    default:
      return false;
  }
}
const List<String> GeneratedMessage_reservedNames = const['hashCode', 'noSuchMethod', 'runtimeType', 'toString', 'fromBuffer', 'fromJson', 'hasRequiredFields', 'isInitialized', 'clear', 'getTagNumber', 'check', 'writeToBuffer', 'writeToCodedBufferWriter', 'mergeFromCodedBufferReader', 'mergeFromBuffer', 'writeToJson', 'mergeFromJson', 'writeToJsonMap', 'mergeFromJsonMap', 'addExtension', 'getExtension', 'setExtension', 'hasExtension', 'clearExtension', 'getField', 'getFieldOrNull', 'getDefaultForField', 'setField', 'hasField', 'clearField', 'extensionsAreInitialized', 'mergeFromMessage', 'mergeUnknownFields', '==', 'info_', 'GeneratedMessage', 'Object', 'eventPlugin', 'createRepeatedField', 'unknownFields', r'$_get', r'$_has', r'$_setBool', r'$_setBytes', r'$_setString', r'$_setFloat', r'$_setDouble', r'$_setSignedInt32', r'$_setUnsignedInt32', r'$_setInt64'];
PbMixin findMixin(String name_A) {
  for (var m in _exportedMixins) {
    if (m.name == name_A) {
      return m;
    }
  }
  return null;
}
class PbMixin {
  final String name;
  final String importFrom;
  final PbMixin parent;
  final List<String> reservedNames;
  const PbMixin._raw(this.name, {this.importFrom, this.parent, this.reservedNames});
  Iterable<PbMixin> findMixinsToApply() {
    var result_A = [this];
    for (var p = parent; p != null; p = p.parent) {
      result_A.add(p);
    }
    return result_A.reversed;
  }
  Iterable<String> findReservedNames() {
    var names = new Set<String>();
    for (var m = this; m != null; m = m.parent) {
      names.add(m.name);
      if (m.reservedNames != null) {
        names.addAll(m.reservedNames);
      }
    }
    return names;
  }
}
const _exportedMixins = const[_pbMapMixin, _pbEventMixin];
const _pbMapMixin = const PbMixin._raw("PbMapMixin", importFrom: "package:protobuf/src/protobuf/mixins/map_mixin.dart", parent: _mapMixin);
const _pbEventMixin = const PbMixin._raw("PbEventMixin", importFrom: "package:protobuf/src/protobuf/mixins/event_mixin.dart", reservedNames: const["changes", "deliverChanges"]);
const List<String> _reservedNamesForMap = const['[]', '[]=', 'addAll', 'containsKey', 'containsValue', 'forEach', 'putIfAbsent', 'remove', 'isEmpty', 'isNotEmpty', 'keys', 'length', 'values'];
const _mapMixin = const PbMixin._raw("MapMixin", importFrom: "dart:collection", reservedNames: _reservedNamesForMap);
class BaseType {
  final FieldDescriptorProto_Type descriptor;
  final String unprefixed;
  final String typeConstantSuffix;
  final String setter;
  final ProtobufContainer generator;
  const BaseType._raw_A(this.descriptor, this.typeConstantSuffix, this.unprefixed, this.setter, this.generator);
  bool get isGroup => descriptor == FieldDescriptorProto_Type.TYPE_GROUP;
  bool get isMessage => descriptor == FieldDescriptorProto_Type.TYPE_MESSAGE;
  bool get isEnum => descriptor == FieldDescriptorProto_Type.TYPE_ENUM;
  String get package => generator == null ? "" : generator.package;
  String get prefixed {
    if (generator == null || generator.packageImportPrefix.isEmpty) {
      return unprefixed;
    }
    return generator.packageImportPrefix + "." + unprefixed;
  }
  String getDartType(String package_A) => (package_A == this.package) ? unprefixed : prefixed;
  String getRepeatedDartType(String package_A) => "List<${getDartType(package_A)}>";
  factory BaseType(FieldDescriptorProto field, GenerationContext ctx) {
    String constSuffix;
    switch (field.type) {
      case FieldDescriptorProto_Type.TYPE_BOOL:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_BOOL, "B", "bool", r"$_setBool", null);

      case FieldDescriptorProto_Type.TYPE_FLOAT:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_FLOAT, "F", "double", r"$_setFloat", null);

      case FieldDescriptorProto_Type.TYPE_DOUBLE:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_DOUBLE, "D", "double", r"$_setDouble", null);

      case FieldDescriptorProto_Type.TYPE_INT32:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_INT32, "3", "int", r"$_setUnsignedInt32", null);

      case FieldDescriptorProto_Type.TYPE_UINT32:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_UINT32, "U3", "int", r"$_setUnsignedInt32", null);

      case FieldDescriptorProto_Type.TYPE_SINT32:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_SINT32, "S3", "int", r"$_setSignedInt32", null);

      case FieldDescriptorProto_Type.TYPE_FIXED32:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_FIXED32, "F3", "int", r"$_setUnsignedInt32", null);

      case FieldDescriptorProto_Type.TYPE_SFIXED32:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_SFIXED32, "SF3", "int", r"$_setSignedInt32", null);

      case FieldDescriptorProto_Type.TYPE_INT64:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_INT64, "6", "Int64", r"$_setInt64", null);

      case FieldDescriptorProto_Type.TYPE_UINT64:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_UINT64, "U6", "Int64", r"$_setInt64", null);

      case FieldDescriptorProto_Type.TYPE_SINT64:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_SINT64, "S6", "Int64", r"$_setInt64", null);

      case FieldDescriptorProto_Type.TYPE_FIXED64:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_FIXED64, "F6", "Int64", r"$_setInt64", null);

      case FieldDescriptorProto_Type.TYPE_SFIXED64:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_SFIXED64, "SF6", "Int64", r"$_setInt64", null);

      case FieldDescriptorProto_Type.TYPE_STRING:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_STRING, "S", "String", r"$_setString", null);

      case FieldDescriptorProto_Type.TYPE_BYTES:
        return const BaseType._raw_A(FieldDescriptorProto_Type.TYPE_BYTES, "Y", "List<int>", r"$_setBytes", null);

      case FieldDescriptorProto_Type.TYPE_GROUP:
        constSuffix = "G";
        break;

      case FieldDescriptorProto_Type.TYPE_MESSAGE:
        constSuffix = "M";
        break;

      case FieldDescriptorProto_Type.TYPE_ENUM:
        constSuffix = "E";
        break;

      default:
        throw new ArgumentError("unimplemented type: ${field.type.name}");
    }
    ProtobufContainer generator_A = ctx.getFieldType(field.typeName);
    if (generator_A == null) {
      throw 'FAILURE: Unknown type reference ${field.typeName}';
    }
    return new BaseType._raw_A(field.type, constSuffix, generator_A.classname, null, generator_A);
  }
}
class ClientApiGenerator {
  final ServiceGenerator service;
  ClientApiGenerator(this.service);
  String get _clientType => 'RpcClient';
  void generate_A(IndentingWriter out) {
    var className = service._descriptor.name;
    out.addBlock('class ${className}Api {', '}', () {
      out.println('${_clientType} _client;');
      out.println('${className}Api(this._client);');
      out.println();
      for (MethodDescriptorProto m in service._descriptor.method) {
        generateMethod(out, m);
      }
    });
    out.println();
  }
  void generateMethod(IndentingWriter out, MethodDescriptorProto m) {
    var methodName = service._methodName(m.name);
    var inputType = service._getDartClassName(m.inputType);
    var outputType = service._getDartClassName(m.outputType);
    out.addBlock('Future<${outputType}> ${methodName}(' 'ClientContext ctx, ${inputType} request) {', '}', () {
      out.println('var emptyResponse = new ${outputType}();');
      out.println('return _client.invoke(ctx, \'${service._descriptor.name}\', ' '\'${m.name}\', request, emptyResponse);');
    });
  }
}
abstract class ProtobufContainer {
  String get package;
  String get classname;
  String get fqname;
  String get packageImportPrefix => package.replaceAll('.', r'$');
  FileGenerator get fileGen;
}
class CodeGenerator extends ProtobufContainer {
  final Stream<List<int>> _streamIn;
  final IOSink _streamOut;
  CodeGenerator(this._streamIn, this._streamOut);
  void generate_A({Map<String, SingleOptionParser> optionParsers, OutputConfiguration config}) {
    if (config == null) {
      config = new DefaultOutputConfiguration();
    }
    var extensions_A = new ExtensionRegistry();
    Dart_options.registerAllExtensions(extensions_A);
    _streamIn.fold(new BytesBuilder(), (builder_A, data_A) => builder_A
        ..add(data_A)).then((builder_A) => builder_A.takeBytes()).then((List<int> bytes) {
      var request = new CodeGeneratorRequest.fromBuffer(bytes, extensions_A);
      var response_A = new CodeGeneratorResponse();
      var options = parseGenerationOptions(request, response_A, optionParsers);
      if (options == null) {
        _streamOut.add(response_A.writeToBuffer());
        return;
      }
      List<FileGenerator> generators = <FileGenerator>[];
      for (FileDescriptorProto file_A in request.protoFile) {
        generators.add(new FileGenerator(file_A));
      }
      link(options, generators);
      for (var gen in generators) {
        var name_A = gen._fileDescriptor.name;
        if (request.fileToGenerate.contains(name_A)) {
          response_A.file.add(gen.generateResponse(config));
        }
      }
      _streamOut.add(response_A.writeToBuffer());
    });
  }
  String get package => '';
  String get classname => null;
  String get fqname => '';
  get fileGen => null;
}
class EnumAlias {
  final EnumValueDescriptorProto value;
  final EnumValueDescriptorProto canonicalValue;
  EnumAlias(this.value, this.canonicalValue);
}
class EnumGenerator extends ProtobufContainer {
  final ProtobufContainer _parent_A;
  final String classname;
  final String fqname;
  final EnumDescriptorProto _descriptor;
  final List<EnumValueDescriptorProto> _canonicalValues = <EnumValueDescriptorProto>[];
  final List<EnumAlias> _aliases = <EnumAlias>[];
  EnumGenerator(EnumDescriptorProto descriptor, ProtobufContainer parent_A) : _parent_A = parent_A, classname = (parent_A == null || parent_A is FileGenerator) ? descriptor.name : '${parent_A.classname}_${descriptor.name}', fqname = (parent_A == null || parent_A.fqname == null) ? descriptor.name : (parent_A.fqname == '.' ? '.${descriptor.name}' : '${parent_A.fqname}.${descriptor.name}'), _descriptor = descriptor {
    for (EnumValueDescriptorProto value_A in descriptor.value) {
      EnumValueDescriptorProto canonicalValue = descriptor.value.firstWhere((v) => v.number == value_A.number);
      if (value_A == canonicalValue) {
        _canonicalValues.add(value_A);
      } else {
        _aliases.add(new EnumAlias(value_A, canonicalValue));
      }
    }
  }
  String get package => _parent_A.package;
  FileGenerator get fileGen => _parent_A.fileGen;
  void register_A(GenerationContext ctx) {
    ctx.registerFieldType(fqname, this);
  }
  String getJsonConstant(FileGenerator usage) {
    var name_A = "${classname}\$json";
    if (usage.package == fileGen.package || packageImportPrefix.isEmpty) {
      return name_A;
    }
    return "${packageImportPrefix}.${name_A}";
  }
  void generate_A(IndentingWriter out) {
    out.addBlock('class ${classname} extends ProtobufEnum {', '}\n', () {
      for (EnumValueDescriptorProto val in _canonicalValues) {
        out.println('static const ${classname} ${val.name} = ' "const ${classname}._(${val.number}, '${val.name}');");
      }
      if (!_aliases.isEmpty) {
        out.println();
        for (EnumAlias alias in _aliases) {
          out.println('static const ${classname} ${alias.value.name} =' ' ${alias.canonicalValue.name};');
        }
      }
      out.println();
      out.println('static const List<${classname}> values =' ' const <${classname}> [');
      for (EnumValueDescriptorProto val in _canonicalValues) {
        out.println('  ${val.name},');
      }
      out.println('];');
      out.println();
      out.println('static final Map<int, ${classname}> _byValue =' ' ProtobufEnum.initByValue(values);');
      out.println('static ${classname} valueOf(int value) =>' ' _byValue[value];');
      out.addBlock('static void ${checkItem}(${classname} v) {', '}', () {
        out.println('if (v is !${classname})' " checkItemFailed(v, '${classname}');");
      });
      out.println();
      out.println('const ${classname}._(int v, String n) ' ': super(v, n);');
    });
  }
  void generateConstants(IndentingWriter out) {
    var name_A = getJsonConstant(fileGen);
    var json = _descriptor.writeToJsonMap();
    out.print("const ${name_A} = ");
    writeJsonConst(out, json);
    out.println(";");
    out.println();
  }
}
class ExtensionGenerator {
  final FieldDescriptorProto _descriptor;
  final ProtobufContainer _parent_A;
  ProtobufField _field;
  String _extendedClassName = "";
  ExtensionGenerator(this._descriptor, this._parent_A);
  void resolve(GenerationContext ctx) {
    _field = new ProtobufField(_descriptor, null, _parent_A, ctx);
    ProtobufContainer extendedType = ctx.getFieldType(_descriptor.extendee);
    if (extendedType != null) {
      _extendedClassName = extendedType.classname;
    }
  }
  String get package => _parent_A.package;
  FileGenerator get fileGen => _parent_A.fileGen;
  String get name {
    if (_field == null) throw new StateError("resolve not called");
    String name_A = _field.dartFieldName;
    return _parent_A is MessageGenerator ? '${_parent_A.classname}.${name_A}' : name_A;
  }
  bool get needsFixnumImport {
    if (_field == null) throw new StateError("resolve not called");
    return _field.needsFixnumImport;
  }
  void addImportsTo(Set<FileGenerator> imports) {
    if (_field == null) throw new StateError("resolve not called");
    var typeGen = _field.baseType.generator;
    if (typeGen != null && typeGen.fileGen != fileGen) {
      imports.add(typeGen.fileGen);
    }
  }
  void generate_A(IndentingWriter out) {
    if (_field == null) throw new StateError("resolve not called");
    String name_A = _field.dartFieldName;
    if (_field.isRepeated) {
      out.print('static final Extension ${name_A} = ' 'new Extension.repeated(\'${_extendedClassName}\', \'${name_A}\', ' '${_field.number}, ${_field.typeConstant}');
      var type_A = _field.baseType;
      if (type_A.isMessage || type_A.isGroup) {
        var dartClass = type_A.getDartType(package);
        out.println(', ${dartClass}.${checkItem}, ${dartClass}.create);');
      } else if (type_A.isEnum) {
        var dartClass = type_A.getDartType(package);
        out.println(', ${dartClass}.${checkItem}, null, ${dartClass}.valueOf);');
      } else {
        out.println(", getCheckFunction(${_field.typeConstant}));");
      }
      return;
    }
    out.print('static final Extension ${name_A} = ' 'new Extension(\'${_extendedClassName}\', \'${name_A}\', ' '${_field.number}, ${_field.typeConstant}');
    String initializer = _field.generateDefaultFunction(package);
    var type_A = _field.baseType;
    if (type_A.isMessage || type_A.isGroup) {
      var dartClass = type_A.getDartType(package);
      out.println(', ${initializer}, ${dartClass}.create);');
    } else if (type_A.isEnum) {
      var dartEnum = type_A.getDartType(package);
      String valueOf_D = '(var v) => ${dartEnum}.valueOf(v)';
      out.println(", ${initializer}, null, ${valueOf_D});");
    } else if (initializer != null) {
      out.println(", ${initializer});");
    } else {
      out.println(");");
    }
  }
}
class FileGenerator extends ProtobufContainer {
  static PbMixin _getDefaultMixin(FileDescriptorProto desc) {
    if (!desc.hasOptions()) return null;
    if (!desc.options.hasExtension(Dart_options.defaultMixin)) {
      return null;
    }
    var name_A = desc.options.getExtension(Dart_options.defaultMixin);
    PbMixin mixin_A = findMixin(name_A);
    if (mixin_A == null) {
      throw ("unknown mixin class: ${name_A}");
    }
    return mixin_A;
  }
  final FileDescriptorProto _fileDescriptor;
  final List<EnumGenerator> enumGenerators = <EnumGenerator>[];
  final List<MessageGenerator> messageGenerators = <MessageGenerator>[];
  final List<ExtensionGenerator> extensionGenerators = <ExtensionGenerator>[];
  final List<ClientApiGenerator> clientApiGenerators = <ClientApiGenerator>[];
  final List<ServiceGenerator> serviceGenerators = <ServiceGenerator>[];
  bool _linked = false;
  FileGenerator(this._fileDescriptor) {
    var defaultMixin_A = _getDefaultMixin(_fileDescriptor);
    for (EnumDescriptorProto enumType in _fileDescriptor.enumType) {
      enumGenerators.add(new EnumGenerator(enumType, this));
    }
    for (DescriptorProto messageType_A in _fileDescriptor.messageType) {
      messageGenerators.add(new MessageGenerator(messageType_A, this, defaultMixin_A));
    }
    for (FieldDescriptorProto extension in _fileDescriptor.extension) {
      extensionGenerators.add(new ExtensionGenerator(extension, this));
    }
    for (ServiceDescriptorProto service in _fileDescriptor.service) {
      var serviceGen = new ServiceGenerator(service, this);
      serviceGenerators.add(serviceGen);
      clientApiGenerators.add(new ClientApiGenerator(serviceGen));
    }
  }
  void resolve(GenerationContext ctx) {
    if (_linked) throw new StateError("cross references already resolved");
    for (var m in messageGenerators) {
      m.resolve(ctx);
    }
    for (var x_A in extensionGenerators) {
      x_A.resolve(ctx);
    }
    _linked = true;
  }
  String get package => _fileDescriptor.package;
  String get classname => '';
  String get fqname => '.${_fileDescriptor.package}';
  FileGenerator get fileGen => this;
  String _fileNameWithoutExtension(Uri filePath) {
    String fileName = filePath.pathSegments.last;
    int index_A = fileName.lastIndexOf(".");
    return index_A == -1 ? fileName : fileName.substring(0, index_A);
  }
  String _generateClassName(Uri protoFilePath) {
    String s = _fileNameWithoutExtension(protoFilePath).replaceAll('-', '_');
    return '${s[0].toUpperCase()}${s.substring(1)}';
  }
  String _generateLibraryName(Uri protoFilePath) {
    var libraryName_A = _fileNameWithoutExtension(protoFilePath).replaceAll('-', '_');
    if (_fileDescriptor.package != '') {
      return _fileDescriptor.package + "_" + libraryName_A;
    }
    return libraryName_A;
  }
  CodeGeneratorResponse_File generateResponse(OutputConfiguration config) {
    IndentingWriter out = new IndentingWriter();
    generate_A(out, config);
    Uri filePath = new Uri.file(_fileDescriptor.name);
    return new CodeGeneratorResponse_File()
        ..name = config.outputPathFor(filePath).path
        ..content = out.toString();
  }
  void generate_A(IndentingWriter out, [OutputConfiguration config = const DefaultOutputConfiguration()]) {
    if (!_linked) throw new StateError("not linked");
    Uri filePath = new Uri.file(_fileDescriptor.name);
    if (filePath.isAbsolute) {
      throw ("FAILURE: File with an absolute path is not supported");
    }
    generateHeader(out, filePath, config);
    for (EnumGenerator e in enumGenerators) {
      e.generate_A(out);
    }
    for (MessageGenerator m in messageGenerators) {
      m.generate_A(out);
    }
    if (!extensionGenerators.isEmpty) {
      String className = _generateClassName(filePath);
      out.addBlock('class ${className} {', '}\n', () {
        for (ExtensionGenerator x_A in extensionGenerators) {
          x_A.generate_A(out);
        }
        out.println('static void registerAllExtensions(ExtensionRegistry ' 'registry) {');
        for (ExtensionGenerator x_A in extensionGenerators) {
          out.println('  registry.add(${x_A.name});');
        }
        out.println('}');
      });
    }
    for (ClientApiGenerator c in clientApiGenerators) {
      c.generate_A(out);
    }
    for (ServiceGenerator s in serviceGenerators) {
      s.generate_A(out);
    }
    for (var e in enumGenerators) {
      e.generateConstants(out);
    }
    for (MessageGenerator m in messageGenerators) {
      m.generateConstants(out);
    }
    for (ServiceGenerator s in serviceGenerators) {
      s.generateConstants(out);
    }
  }
  void generateHeader(IndentingWriter out, Uri filePath, [OutputConfiguration config = const DefaultOutputConfiguration()]) {
    String libraryName_A = _generateLibraryName(filePath);
    out.println('///\n' '//  Generated code. Do not modify.\n' '///\n' 'library ${libraryName_A};\n');
    if (_fileDescriptor.service.isNotEmpty) {
      out.println("import 'dart:async';\n");
    }
    if (_needsFixnumImport) {
      out.println("import 'package:fixnum/fixnum.dart';");
    }
    out.println("import 'package:protobuf/protobuf.dart';");
    var mixinImports = findMixinsToImport();
    var importNames = mixinImports.keys.toList();
    importNames.sort();
    for (var imp in importNames) {
      var symbols = mixinImports[imp];
      out.println("import '${imp}' show ${symbols.join(', ')};");
    }
    for (var imported in _findProtosToImport()) {
      String filename = imported._fileDescriptor.name;
      Uri importPath = new Uri.file(filename);
      if (importPath.isAbsolute) {
        throw ("FAILURE: Import with absolute path is not supported");
      }
      Uri resolvedImport = config.resolveImport(importPath, filePath);
      out.print("import '${resolvedImport}'");
      if (package != imported.package && imported.package.isNotEmpty) {
        out.print(' as ${imported.packageImportPrefix}');
      }
      out.println(';');
    }
    out.println();
  }
  bool get _needsFixnumImport {
    for (var m in messageGenerators) {
      if (m.needsFixnumImport) return true;
    }
    for (var x_A in extensionGenerators) {
      if (x_A.needsFixnumImport) return true;
    }
    return false;
  }
  Set<FileGenerator> _findProtosToImport() {
    var imports = new Set<FileGenerator>.identity();
    for (var m in messageGenerators) {
      m.addImportsTo(imports);
    }
    for (var x_A in extensionGenerators) {
      x_A.addImportsTo(imports);
    }
    for (var x_A in serviceGenerators) {
      x_A.addImportsTo(imports);
    }
    imports.remove(this);
    return imports;
  }
  Map<String, List<String>> findMixinsToImport() {
    var mixins = new Set<PbMixin>();
    for (MessageGenerator m in messageGenerators) {
      m.addMixinsTo(mixins);
    }
    var imports = {};
    for (var m in mixins) {
      var imp = m.importFrom;
      List<String> symbols = imports[imp];
      if (symbols == null) {
        symbols = [];
        imports[imp] = symbols;
      }
      symbols.add(m.name);
    }
    for (var imp in imports.keys) {
      imports[imp].sort();
    }
    return imports;
  }
}
void link(GenerationOptions options, Iterable<FileGenerator> files) {
  GenerationContext ctx = new GenerationContext(options);
  for (var f in files) {
    ctx.registerProtoFile(f);
    for (var m in f.messageGenerators) {
      m.register_A(ctx);
    }
    for (var e in f.enumGenerators) {
      e.register_A(ctx);
    }
  }
  for (var f in files) {
    f.resolve(ctx);
  }
  for (var f in files) {
    for (var s in f.serviceGenerators) {
      s.resolve(ctx);
    }
  }
}
class GenerationContext {
  final GenerationOptions options;
  final Map<String, FileGenerator> _files = <String, FileGenerator>{};
  final Map<String, ProtobufContainer> _typeRegistry = <String, ProtobufContainer>{};
  GenerationContext(this.options);
  void registerProtoFile(FileGenerator f) {
    _files[f._fileDescriptor.name] = f;
  }
  void registerFieldType(String name_A, ProtobufContainer type_A) {
    _typeRegistry[name_A] = type_A;
  }
  ProtobufContainer getFieldType(String name_A) => _typeRegistry[name_A];
}
const checkItem = '\$checkItem';
class MessageGenerator extends ProtobufContainer {
  static final List<String> reservedWords = ['assert', 'break', 'case', 'catch', 'class', 'const', 'continue', 'default', 'do', 'else', 'enum', 'extends', 'false', 'final', 'finally', 'for', 'if', 'in', 'is', 'new', 'null', 'rethrow', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try', 'var', 'void', 'while', 'with'];
  static final List<String> generatedNames = ['create', 'createRepeated', 'getDefault', checkItem];
  static PbMixin _getMixin(DescriptorProto desc, PbMixin defaultValue) {
    if (!desc.hasOptions()) return defaultValue;
    if (!desc.options.hasExtension(Dart_options.mixin)) return defaultValue;
    String name_A = desc.options.getExtension(Dart_options.mixin);
    if (name_A.isEmpty) return null;
    var mixin_A = findMixin(name_A);
    if (mixin_A == null) {
      throw ("unknown mixin class: ${name_A}");
    }
    return mixin_A;
  }
  final String classname;
  final String fqname;
  final PbMixin mixin_A;
  final ProtobufContainer _parent_A;
  final DescriptorProto _descriptor;
  final List<EnumGenerator> _enumGenerators = <EnumGenerator>[];
  final List<MessageGenerator> _messageGenerators = <MessageGenerator>[];
  final List<ExtensionGenerator> _extensionGenerators = <ExtensionGenerator>[];
  List<ProtobufField> _fieldList;
  final Set<String> _methodNames = new Set<String>();
  MessageGenerator(DescriptorProto descriptor, ProtobufContainer parent_A, PbMixin defaultMixin_A) : _descriptor = descriptor, _parent_A = parent_A, classname = (parent_A.classname == '') ? descriptor.name : '${parent_A.classname}_${descriptor.name}', fqname = (parent_A == null || parent_A.fqname == null) ? descriptor.name : (parent_A.fqname == '.' ? '.${descriptor.name}' : '${parent_A.fqname}.${descriptor.name}'), mixin_A = _getMixin(descriptor, defaultMixin_A) {
    for (EnumDescriptorProto e in _descriptor.enumType) {
      _enumGenerators.add(new EnumGenerator(e, this));
    }
    for (DescriptorProto n in _descriptor.nestedType) {
      _messageGenerators.add(new MessageGenerator(n, this, defaultMixin_A));
    }
    for (FieldDescriptorProto x_A in _descriptor.extension) {
      _extensionGenerators.add(new ExtensionGenerator(x_A, this));
    }
  }
  String get package => _parent_A.package;
  FileGenerator get fileGen => _parent_A.fileGen;
  void checkResolved() {
    if (_fieldList == null) {
      throw new StateError("message not resolved: ${fqname}");
    }
  }
  String getJsonConstant(FileGenerator usage) {
    var name_A = "${classname}\$json";
    if (usage.package == fileGen.package || packageImportPrefix.isEmpty) {
      return name_A;
    }
    return "${packageImportPrefix}.${name_A}";
  }
  void addMixinsTo(Set<PbMixin> output) {
    if (mixin_A != null) {
      output.addAll(mixin_A.findMixinsToApply());
    }
    for (var m in _messageGenerators) {
      m.addMixinsTo(output);
    }
  }
  void register_A(GenerationContext ctx) {
    ctx.registerFieldType(fqname, this);
    for (var m in _messageGenerators) {
      m.register_A(ctx);
    }
    for (var e in _enumGenerators) {
      e.register_A(ctx);
    }
  }
  void resolve(GenerationContext ctx) {
    if (_fieldList != null) throw new StateError("message already resolved");
    var sorted_A = new List<FieldDescriptorProto>.from(_descriptor.field)
        ..sort((FieldDescriptorProto a, FieldDescriptorProto b) {
      if (a.number < b.number) return -1;
      if (a.number > b.number) return 1;
      throw "multiple fields defined for tag ${a.number} in ${fqname}";
    });
    _fieldList = <ProtobufField>[];
    for (FieldDescriptorProto field in sorted_A) {
      int index_A = _fieldList.length;
      _fieldList.add(new ProtobufField(field, index_A, this, ctx));
    }
    for (var m in _messageGenerators) {
      m.resolve(ctx);
    }
    for (var x_A in _extensionGenerators) {
      x_A.resolve(ctx);
    }
  }
  bool get needsFixnumImport {
    if (_fieldList == null) throw new StateError("message not resolved");
    for (var field in _fieldList) {
      if (field.needsFixnumImport) return true;
    }
    for (var m in _messageGenerators) {
      if (m.needsFixnumImport) return true;
    }
    for (var x_A in _extensionGenerators) {
      if (x_A.needsFixnumImport) return true;
    }
    return false;
  }
  void addImportsTo(Set<FileGenerator> imports) {
    if (_fieldList == null) throw new StateError("message not resolved");
    for (var field in _fieldList) {
      var typeGen = field.baseType.generator;
      if (typeGen != null && typeGen.fileGen != fileGen) {
        imports.add(typeGen.fileGen);
      }
    }
    for (var m in _messageGenerators) {
      m.addImportsTo(imports);
    }
    for (var x_A in _extensionGenerators) {
      x_A.addImportsTo(imports);
    }
  }
  void generate_A(IndentingWriter out) {
    checkResolved();
    _methodNames.clear();
    _methodNames.addAll(reservedWords);
    _methodNames.addAll(GeneratedMessage_reservedNames);
    _methodNames.addAll(generatedNames);
    if (mixin_A != null) {
      _methodNames.addAll(mixin_A.findReservedNames());
    }
    for (EnumGenerator e in _enumGenerators) {
      e.generate_A(out);
    }
    for (MessageGenerator m in _messageGenerators) {
      m.generate_A(out);
    }
    var mixinClause = '';
    if (mixin_A != null) {
      var mixinNames = mixin_A.findMixinsToApply().map((m) => m.name);
      mixinClause = ' with ${mixinNames.join(", ")}';
    }
    out.addBlock('class ${classname} extends GeneratedMessage${mixinClause} {', '}', () {
      out.addBlock('static final BuilderInfo _i = new BuilderInfo(\'${classname}\')', ';', () {
        for (ProtobufField field in _fieldList) {
          out.println(field.generateBuilderInfoCall(package));
        }
        if (_descriptor.extensionRange.length > 0) {
          out.println('..hasExtensions = true');
        }
        if (!_hasRequiredFields_A(this, new Set())) {
          out.println('..hasRequiredFields = false');
        }
      });
      for (ExtensionGenerator x_A in _extensionGenerators) {
        x_A.generate_A(out);
      }
      out.println();
      out.println('${classname}() : super();');
      out.println('${classname}.fromBuffer(List<int> i,' ' [ExtensionRegistry r = ExtensionRegistry.EMPTY])' ' : super.fromBuffer(i, r);');
      out.println('${classname}.fromJson(String i,' ' [ExtensionRegistry r = ExtensionRegistry.EMPTY])' ' : super.fromJson(i, r);');
      out.println('${classname} clone() =>' ' new ${classname}()..mergeFromMessage(this);');
      out.println('BuilderInfo get info_ => _i;');
      out.println('static ${classname} create() =>' ' new ${classname}();');
      out.println('static PbList<${classname}> createRepeated() =>' ' new PbList<${classname}>();');
      out.addBlock('static ${classname} getDefault() {', '}', () {
        out.println('if (_defaultInstance == null) _defaultInstance = new _Readonly${classname}();');
        out.println('return _defaultInstance;');
      });
      out.println('static ${classname} _defaultInstance;');
      out.addBlock('static void ${checkItem}(${classname} v) {', '}', () {
        out.println('if (v is !${classname})' " checkItemFailed(v, '${classname}');");
      });
      generateFieldsAccessorsMutators(out);
    });
    out.println();
    out.println('class _Readonly${classname} extends ${classname} with ReadonlyMessageMixin {}');
    out.println();
  }
  bool _hasRequiredFields_A(MessageGenerator type_A, Set alreadySeen) {
    if (type_A._fieldList == null) throw new StateError("message not resolved");
    if (alreadySeen.contains(type_A.fqname)) {
      return false;
    }
    alreadySeen.add(type_A.fqname);
    if (type_A._descriptor.extensionRange.length > 0) {
      return true;
    }
    for (ProtobufField field in type_A._fieldList) {
      if (field.isRequired) {
        return true;
      }
      if (field.baseType.isMessage) {
        MessageGenerator child = field.baseType.generator;
        if (_hasRequiredFields_A(child, alreadySeen)) {
          return true;
        }
      }
    }
    return false;
  }
  void generateFieldsAccessorsMutators(IndentingWriter out) {
    for (ProtobufField field in _fieldList) {
      out.println();
      String identifier = field.dartFieldName;
      String hasIdentifier = field.hasMethodName;
      String clearIdentifier = field.clearMethodName;
      if (!field.isRepeated) {
        while (_methodNames.contains(identifier) || _methodNames.contains(hasIdentifier) || _methodNames.contains(clearIdentifier)) {
          identifier += '_' + field.number.toString();
          hasIdentifier += '_' + field.number.toString();
          clearIdentifier += '_' + field.number.toString();
        }
        _methodNames.add(identifier);
        _methodNames.add(hasIdentifier);
        _methodNames.add(clearIdentifier);
      } else {
        while (_methodNames.contains(identifier)) {
          identifier += '_' + field.number.toString();
        }
        _methodNames.add(identifier);
      }
      var fieldTypeString = field.getDartType(package);
      var defaultExpr = field.getDefaultExpr();
      out.println('${fieldTypeString} get ${identifier}' ' => \$_get(${field.index}, ${field.number}, ${defaultExpr});');
      if (!field.isRepeated) {
        var fastSetter = field.baseType.setter;
        if (fastSetter != null) {
          out.println('void set ${identifier}' '(${fieldTypeString} v) { ' '${fastSetter}(${field.index}, ${field.number}, v);' ' }');
        } else {
          out.println('void set ${identifier}' '(${fieldTypeString} v) { ' 'setField(${field.number}, v);' ' }');
        }
        out.println('bool ${hasIdentifier}() =>' ' \$_has(${field.index}, ${field.number});');
        out.println('void ${clearIdentifier}() =>' ' clearField(${field.number});');
      }
    }
  }
  void generateConstants(IndentingWriter out) {
    const nestedTypeTag = 3;
    const enumTypeTag = 4;
    assert(_descriptor.info_.fieldInfo[nestedTypeTag].name == "nestedType");
    assert(_descriptor.info_.fieldInfo[enumTypeTag].name == "enumType");
    var name_A = getJsonConstant(fileGen);
    var json = _descriptor.writeToJsonMap();
    var nestedTypeNames = _messageGenerators.map((m) => m.getJsonConstant(fileGen)).toList();
    var nestedEnumNames = _enumGenerators.map((e) => e.getJsonConstant(fileGen)).toList();
    out.addBlock("const ${name_A} = const {", "};", () {
      for (var key_A in json.keys) {
        out.print("'${key_A}': ");
        if (key_A == "${nestedTypeTag}") {
          out.println("const [${nestedTypeNames.join(", ")}],");
          continue;
        } else if (key_A == "${enumTypeTag}") {
          out.println("const [${nestedEnumNames.join(", ")}],");
          continue;
        }
        writeJsonConst(out, json[key_A]);
        out.println(",");
      }
    });
    out.println();
    for (var m in _messageGenerators) {
      m.generateConstants(out);
    }
    for (var e in _enumGenerators) {
      e.generateConstants(out);
    }
  }
}
bool genericOptionsParser(CodeGeneratorRequest request, CodeGeneratorResponse response_A, Map<String, SingleOptionParser> parsers) {
  var parameter = request.parameter != null ? request.parameter : '';
  var options = parameter.trim().split(',');
  var errors_A = [];
  for (var option in options) {
    option = option.trim();
    if (option.isEmpty) continue;
    var reportError = (details) {
      errors_A.add('Error found trying to parse the option: ${option}.\n${details}');
    };
    var nameValue = option.split('=');
    if (nameValue.length != 1 && nameValue.length != 2) {
      reportError('Options should be a single token, or a name=value pair');
      continue;
    }
    var name_A = nameValue[0].trim();
    var parser = parsers[name_A];
    if (parser == null) {
      reportError('Unknown option (${name_A}).');
      continue;
    }
    var value_A = nameValue.length > 1 ? nameValue[1].trim() : null;
    parser.parse_B(name_A, value_A, reportError);
  }
  if (errors_A.length == 0) return true;
  response_A.error = errors_A.join('\n');
  return false;
}
class GenerationOptions {
  final Map<String, String> fieldNameOverrides;
  GenerationOptions([this.fieldNameOverrides = const{}]);
}
abstract class SingleOptionParser {
  void parse_B(String name_A, String value_A, onError_A(String details));
}
GenerationOptions parseGenerationOptions(CodeGeneratorRequest request, CodeGeneratorResponse response_A, [Map<String, SingleOptionParser> parsers]) {
  var fieldNameOptionParser = new FieldNameOptionParser();
  var map_A = {};
  if (parsers != null) parsers.forEach((k, v) {
    map_A[k] = v;
  });
  map_A['field_name'] = fieldNameOptionParser;
  if (genericOptionsParser(request, response_A, map_A)) {
    return new GenerationOptions(fieldNameOptionParser.mappings);
  }
  return null;
}
class FieldNameOptionParser implements SingleOptionParser {
  final Map<String, String> mappings = {};
  void parse_B(String name_A, String value_A, onError_A(String message)) {
    if (value_A == null) {
      onError_A('Invalid field_name option, expected a non-emtpy value.');
      return;
    }
    List<String> fromTo = value_A.split('|');
    if (fromTo.length != 2) {
      onError_A('Invalid field_name option, expected a single "|" separator.');
      return;
    }
    var fromName = fromTo[0].trim();
    var toName = fromTo[1].trim();
    if (fromName.isEmpty || toName.isEmpty) {
      onError_A('Invalid field_name option, ' '"from" and "to" names should not be empty.');
      return;
    }
    mappings['.${fromName}'] = toName;
  }
}
abstract class OutputConfiguration {
  const OutputConfiguration();
  String replacePathExtension(String filePath) => '${withoutExtension(filePath)}.pb.dart';
  Uri replaceUriExtension(Uri file_A) => url.toUri(replacePathExtension(url.fromUri_A(file_A)));
  Uri resolveImport(Uri target_A, Uri source_A);
  Uri outputPathFor(Uri inputPath);
}
class DefaultOutputConfiguration extends OutputConfiguration {
  const DefaultOutputConfiguration();
  Uri outputPathFor(Uri input_A) => replaceUriExtension(input_A);
  Uri resolveImport(Uri target_A, Uri source_A) {
    var builder_A = url;
    var targetPath = builder_A.fromUri_A(target_A);
    var sourceDir = builder_A.dirname(builder_A.fromUri_A(source_A));
    return builder_A.toUri(replacePathExtension(builder_A.relative(targetPath, from: sourceDir)));
  }
}
class ProtobufField {
  static final RegExp HEX_LITERAL_REGEX = new RegExp(r'^0x[0-9a-f]+$', multiLine: false, caseSensitive: false);
  static final RegExp INTEGER_LITERAL_REGEX = new RegExp(r'^[+-]?[0-9]+$');
  static final RegExp DECIMAL_LITERAL_REGEX_A = new RegExp(r'^[+-]?([0-9]*)\.[0-9]+(e[+-]?[0-9]+)?$', multiLine: false, caseSensitive: false);
  static final RegExp DECIMAL_LITERAL_REGEX_B = new RegExp(r'^[+-]?[0-9]+e[+-]?[0-9]+$', multiLine: false, caseSensitive: false);
  final FieldDescriptorProto _field;
  final int index;
  final String fqname;
  final BaseType baseType;
  final GenerationOptions _genOptions;
  ProtobufField(FieldDescriptorProto field, this.index, ProtobufContainer parent_A, GenerationContext ctx) : _field = field, fqname = '${parent_A.fqname}.${field.name}', baseType = new BaseType(field, ctx), _genOptions = ctx.options;
  int get number => _field.number;
  bool get isRequired => _field.label == FieldDescriptorProto_Label.LABEL_REQUIRED;
  bool get isRepeated => _field.label == FieldDescriptorProto_Label.LABEL_REPEATED;
  bool get isPacked => isRepeated && _field.options != null && _field.options.packed;
  bool get needsFixnumImport => baseType.unprefixed == "Int64";
  String getDartType(String package) {
    if (isRepeated) return baseType.getRepeatedDartType(package);
    return baseType.getDartType(package);
  }
  String get typeConstant {
    String prefix = 'O';
    if (isRequired) {
      prefix = 'Q';
    } else if (isPacked) {
      prefix = 'K';
    } else if (isRepeated) {
      prefix = 'P';
    }
    return "PbFieldType." + prefix + baseType.typeConstantSuffix;
  }
  String get dartFieldName {
    String name_A = _fieldMethodSuffix;
    return '${name_A[0].toLowerCase()}${name_A.substring(1)}';
  }
  String get hasMethodName => 'has${_fieldMethodSuffix}';
  String get clearMethodName => 'clear${_fieldMethodSuffix}';
  String get _fieldMethodSuffix {
    String underscoresToCamelCase(String s) {
      cap(s) => s.isEmpty ? s : '${s[0].toUpperCase()}${s.substring(1)}';
      return s.split('_').map(cap).join('');
    }
    if (baseType.isGroup) {
      String name_A = _field.typeName;
      int index_A = name_A.lastIndexOf('.');
      if (index_A != -1) {
        name_A = name_A.substring(index_A + 1);
      }
      return underscoresToCamelCase(name_A);
    }
    var name_A = _genOptions.fieldNameOverrides[fqname];
    return name_A != null ? name_A : underscoresToCamelCase(_field.name);
  }
  String generateBuilderInfoCall(String package) {
    String quotedName = "'${dartFieldName}'";
    String type_A = baseType.getDartType(package);
    if (isRepeated) {
      if (baseType.isMessage || baseType.isGroup) {
        return '..pp(${number}, ${quotedName}, ${typeConstant},' ' ${type_A}.${checkItem}, ${type_A}.create)';
      } else if (baseType.isEnum) {
        return '..pp(${number}, ${quotedName}, ${typeConstant},' ' ${type_A}.${checkItem}, null, ${type_A}.valueOf)';
      } else {
        return '..p(${number}, ${quotedName}, ${typeConstant})';
      }
    }
    String makeDefault = generateDefaultFunction(package);
    if (baseType.isEnum) {
      String valueOf_D = '${type_A}.valueOf';
      return '..e(${number}, ${quotedName}, ${typeConstant}, ${makeDefault}, ${valueOf_D})';
    }
    String prefix = '..a(${number}, ${quotedName}, ${typeConstant}';
    if (makeDefault == null) return prefix + ')';
    if (baseType.isMessage || baseType.isGroup) {
      return prefix + ', ${makeDefault}, ${type_A}.create)';
    }
    return prefix + ', ${makeDefault})';
  }
  String getDefaultExpr() {
    if (isRepeated) return "null";
    switch (_field.type) {
      case FieldDescriptorProto_Type.TYPE_BOOL:
        return _getDefaultAsBoolExpr("false");

      case FieldDescriptorProto_Type.TYPE_INT32: case FieldDescriptorProto_Type.TYPE_UINT32: case FieldDescriptorProto_Type.TYPE_SINT32: case FieldDescriptorProto_Type.TYPE_FIXED32: case FieldDescriptorProto_Type.TYPE_SFIXED32:
        return _getDefaultAsInt32Expr("0");

      case FieldDescriptorProto_Type.TYPE_STRING:
        return _getDefaultAsStringExpr("''");

      default:
        return "null";
    }
  }
  String generateDefaultFunction(String package) {
    if (isRepeated) {
      return '() => new PbList()';
    }
    bool samePackage = package == baseType.package;
    switch (_field.type) {
      case FieldDescriptorProto_Type.TYPE_BOOL:
        return _getDefaultAsBoolExpr(null);

      case FieldDescriptorProto_Type.TYPE_FLOAT: case FieldDescriptorProto_Type.TYPE_DOUBLE:
        if (!_field.hasDefaultValue()) {
          return null;
        } else if ('0.0' == _field.defaultValue || '0' == _field.defaultValue) {
          return null;
        } else if (_field.defaultValue == 'inf') {
          return 'double.INFINITY';
        } else if (_field.defaultValue == '-inf') {
          return 'double.NEGATIVE_INFINITY';
        } else if (_field.defaultValue == 'nan') {
          return 'double.NAN';
        } else if (HEX_LITERAL_REGEX.hasMatch(_field.defaultValue)) {
          return '(${_field.defaultValue}).toDouble()';
        } else if (INTEGER_LITERAL_REGEX.hasMatch(_field.defaultValue)) {
          return '${_field.defaultValue}.0';
        } else if (DECIMAL_LITERAL_REGEX_A.hasMatch(_field.defaultValue) || DECIMAL_LITERAL_REGEX_B.hasMatch(_field.defaultValue)) {
          return '${_field.defaultValue}';
        }
        throw _invalidDefaultValue;

      case FieldDescriptorProto_Type.TYPE_INT32: case FieldDescriptorProto_Type.TYPE_UINT32: case FieldDescriptorProto_Type.TYPE_SINT32: case FieldDescriptorProto_Type.TYPE_FIXED32: case FieldDescriptorProto_Type.TYPE_SFIXED32:
        return _getDefaultAsInt32Expr(null);

      case FieldDescriptorProto_Type.TYPE_INT64: case FieldDescriptorProto_Type.TYPE_UINT64: case FieldDescriptorProto_Type.TYPE_SINT64: case FieldDescriptorProto_Type.TYPE_FIXED64: case FieldDescriptorProto_Type.TYPE_SFIXED64:
        var value_A = '0';
        if (_field.hasDefaultValue()) value_A = _field.defaultValue;
        if (value_A == '0') return 'Int64.ZERO';
        return "parseLongInt('${value_A}')";

      case FieldDescriptorProto_Type.TYPE_STRING:
        return _getDefaultAsStringExpr(null);

      case FieldDescriptorProto_Type.TYPE_BYTES:
        if (!_field.hasDefaultValue() || _field.defaultValue.isEmpty) {
          return null;
        }
        String byteList = _field.defaultValue.codeUnits.map((b) => '0x${b.toRadixString(16)}').join(',');
        return '() => <int>[${byteList}]';

      case FieldDescriptorProto_Type.TYPE_GROUP: case FieldDescriptorProto_Type.TYPE_MESSAGE:
        if (samePackage) return '${baseType.unprefixed}.getDefault';
        return "${baseType.prefixed}.getDefault";

      case FieldDescriptorProto_Type.TYPE_ENUM:
        var className = samePackage ? baseType.unprefixed : baseType.prefixed;
        EnumGenerator gen = baseType.generator;
        if (_field.hasDefaultValue() && !_field.defaultValue.isEmpty) {
          return '${className}.${_field.defaultValue}';
        } else if (!gen._canonicalValues.isEmpty) {
          return '${className}.${gen._canonicalValues[0].name}';
        }
        return null;

      default:
        throw _typeNotImplemented("generatedDefaultFunction");
    }
  }
  String _getDefaultAsBoolExpr(String noDefault) {
    if (_field.hasDefaultValue() && 'false' != _field.defaultValue) {
      return '${_field.defaultValue}';
    }
    return noDefault;
  }
  String _getDefaultAsStringExpr(String noDefault) {
    if (!_field.hasDefaultValue() || _field.defaultValue.isEmpty) {
      return noDefault;
    }
    String value_A = _field.defaultValue.replaceAll(r'$', r'\$');
    return '\'${value_A}\'';
  }
  String _getDefaultAsInt32Expr(String noDefault) {
    if (_field.hasDefaultValue() && '0' != _field.defaultValue) {
      return '${_field.defaultValue}';
    }
    return noDefault;
  }
  get _invalidDefaultValue => "dart-protoc-plugin:" " invalid default value (${_field.defaultValue})" " found in field ${fqname}";
  _typeNotImplemented(String methodName) => "dart-protoc-plugin:" " ${methodName} not implemented for type (${_field.type})" " found in field ${fqname}";
}
class ServiceGenerator {
  final ServiceDescriptorProto _descriptor;
  final FileGenerator fileGen;
  final _deps = <String, MessageGenerator>{};
  final _undefinedDeps = <String, String>{};
  ServiceGenerator(this._descriptor, this.fileGen);
  String get classname {
    if (_descriptor.name.endsWith("Service")) {
      return _descriptor.name + "Base";
    } else {
      return _descriptor.name + "ServiceBase";
    }
  }
  void resolve(GenerationContext ctx) {
    for (var m in _methodDescriptors) {
      _addDependency(ctx, m.inputType, "input type of ${m.name}");
      _addDependency(ctx, m.outputType, "output type of ${m.name}");
    }
    _resolveMoreTypes(ctx);
  }
  void _resolveMoreTypes(GenerationContext ctx) {}
  void _addDependency(GenerationContext ctx, String fqname, String location_A) {
    if (_deps.containsKey(fqname)) return;
    MessageGenerator mg = ctx.getFieldType(fqname);
    if (mg == null) {
      _undefinedDeps[fqname] = location_A;
      return;
    }
    _addDepsRecursively(mg);
  }
  void _addDepsRecursively(MessageGenerator mg) {
    if (_deps.containsKey(mg.fqname)) return;
    mg.checkResolved();
    _deps[mg.fqname] = mg;
    for (var field in mg._fieldList) {
      if (field.baseType.isGroup || field.baseType.isMessage) {
        _addDepsRecursively(field.baseType.generator);
      }
    }
  }
  void addImportsTo(Set<FileGenerator> imports) {
    for (var mg in _deps.values) {
      imports.add(mg.fileGen);
    }
  }
  String _getDartClassName(String fqname) {
    var mg = _deps[fqname];
    if (mg == null) {
      var location_A = _undefinedDeps[fqname];
      throw 'FAILURE: Unknown type reference (${fqname}) for ${location_A}';
    }
    if (fileGen.package == mg.fileGen.package || mg.fileGen.package == "") {
      return mg.classname;
    }
    return mg.packageImportPrefix + "." + mg.classname;
  }
  List<MethodDescriptorProto> get _methodDescriptors => _descriptor.method;
  String _methodName(String name_A) => name_A.substring(0, 1).toLowerCase() + name_A.substring(1);
  String get _parentClass => 'GeneratedService';
  void _generateStub(IndentingWriter out, MethodDescriptorProto m) {
    var methodName = _methodName(m.name);
    var inputClass = _getDartClassName(m.inputType);
    var outputClass = _getDartClassName(m.outputType);
    out.println('Future<${outputClass}> ${methodName}(' 'ServerContext ctx, ${inputClass} request);');
  }
  void _generateStubs(IndentingWriter out) {
    for (MethodDescriptorProto m in _methodDescriptors) {
      _generateStub(out, m);
    }
    out.println();
  }
  void _generateRequestMethod(IndentingWriter out) {
    out.addBlock('GeneratedMessage createRequest(String method) {', '}', () {
      out.addBlock("switch (method) {", "}", () {
        for (MethodDescriptorProto m in _methodDescriptors) {
          var inputClass = _getDartClassName(m.inputType);
          out.println("case '${m.name}': return new ${inputClass}();");
        }
        out.println("default: " "throw new ArgumentError('Unknown method: \$method');");
      });
    });
    out.println();
  }
  void _generateDispatchMethod(out) {
    out.addBlock('Future<GeneratedMessage> handleCall(ServerContext ctx, ' 'String method, GeneratedMessage request) {', '}', () {
      out.addBlock("switch (method) {", "}", () {
        for (MethodDescriptorProto m in _methodDescriptors) {
          var methodName = _methodName(m.name);
          out.println("case '${m.name}': return ${methodName}(ctx, request);");
        }
        out.println("default: " "throw new ArgumentError('Unknown method: \$method');");
      });
    });
    out.println();
  }
  void _generateMoreClassMembers(out) {}
  void generate_A(IndentingWriter out) {
    out.addBlock('abstract class ${classname} extends ' '${_parentClass} {', '}', () {
      _generateStubs(out);
      _generateRequestMethod(out);
      _generateDispatchMethod(out);
      _generateMoreClassMembers(out);
      out.println("Map<String, dynamic> get \$json => ${jsonConstant};");
      out.println("Map<String, dynamic> get \$messageJson =>" " ${messageJsonConstant};");
    });
    out.println();
  }
  String get jsonConstant => "${_descriptor.name}\$json";
  String get messageJsonConstant => "${_descriptor.name}\$messageJson";
  void generateConstants(IndentingWriter out) {
    out.print("const ${jsonConstant} = ");
    writeJsonConst(out, _descriptor.writeToJsonMap());
    out.println(";");
    out.println();
    var typeConstants = <String, String>{};
    for (var key_A in _deps.keys) {
      typeConstants[key_A] = _deps[key_A].getJsonConstant(fileGen);
    }
    out.addBlock("const ${messageJsonConstant} = const {", "};", () {
      for (var key_A in typeConstants.keys) {
        var typeConst = typeConstants[key_A];
        out.println("'${key_A}': ${typeConst},");
      }
    });
    out.println();
    if (_undefinedDeps.isNotEmpty) {
      for (var name_A in _undefinedDeps.keys) {
        var location_A = _undefinedDeps[name_A];
        out.println("// can't resolve (${name_A}) used by ${location_A}");
      }
      out.println();
    }
  }
}
void writeJsonConst(IndentingWriter out, val) {
  if (val is Map) {
    if (val.values.any(_nonEmptyListOrMap)) {
      out.addBlock("const {", "}", () => _writeMapItems(out, val, vertical: true), endWithNewline: false);
    } else {
      out.print("const {");
      _writeMapItems(out, val);
      out.print("}");
    }
  } else if (val is List) {
    if (val.any(_nonEmptyListOrMap)) {
      out.addBlock("const [", "]", () => _writeListItems(out, val, vertical: true), endWithNewline: false);
    } else {
      out.print("const [");
      _writeListItems(out, val);
      out.print("]");
    }
  } else if (val is String) {
    _writeString(out, val);
  } else if (val is num || val is bool) {
    out.print(val.toString());
  } else if (val == null) {
    out.print("null");
  } else {
    throw "not JSON: ${val}";
  }
}
bool _nonEmptyListOrMap(x_A) {
  if (x_A is List && !x_A.isEmpty) return true;
  if (x_A is Map && !x_A.isEmpty) return true;
  return false;
}
void _writeString(IndentingWriter out, String val) {
  if (_maybeWriteSingleLineString(out, val)) return;
  var quote = "'''";
  out.addUnindentedBlock("r${quote}", "${quote}", () {
    out.print(val.replaceAll(quote, '${quote} "${quote}" r${quote}'));
  }, endWithNewline: false);
}
bool _maybeWriteSingleLineString(IndentingWriter out, String val) {
  if (val.contains("\n")) return false;
  var prefix = '';
  if (val.contains(r'$') || val.contains(r'\')) {
    prefix = 'r';
  }
  if (!val.contains("'")) {
    out.print("${prefix}'${val}'");
    return true;
  } else if (!val.contains('"')) {
    out.print('${prefix}"${val}"');
    return true;
  } else if (!val.contains("'''")) {
    out.print("${prefix}'''${val}'''");
    return true;
  } else if (!val.contains('"""')) {
    out.print('${prefix}"""${val}"""');
    return true;
  } else {
    return false;
  }
}
void _writeListItems(IndentingWriter out, List val, {bool vertical: false}) {
  bool first_A = true;
  for (var item in val) {
    if (!first_A && !vertical) {
      out.print(", ");
    }
    writeJsonConst(out, item);
    if (vertical) {
      out.println(",");
    }
    first_A = false;
  }
}
void _writeMapItems(IndentingWriter out, Map<String, dynamic> val, {bool vertical: false}) {
  bool first_A = true;
  for (String key_A in val.keys) {
    if (!first_A && !vertical) out.print(", ");
    _writeString(out, key_A);
    out.print(": ");
    writeJsonConst(out, val[key_A]);
    if (vertical) {
      out.println(",");
    }
    first_A = false;
  }
}
class IndentingWriter {
  final StringBuffer _buffer_C = new StringBuffer();
  String _indent_A = "";
  bool _needIndent = true;
  void print(String text) {
    var lastNewline = text.lastIndexOf('\n');
    if (lastNewline == -1) {
      _writeChunk(text);
      return;
    }
    for (String line in text.substring(0, lastNewline).split('\n')) {
      _writeChunk(line);
      _newline();
    }
    _writeChunk(text.substring(lastNewline + 1));
  }
  void println([String text = '']) {
    print(text);
    _newline();
  }
  void addBlock(String start_A, String end_A, void body(), {endWithNewline: true}) {
    _addBlock(start_A, end_A, body, endWithNewline, _indent_A + '  ');
  }
  void addUnindentedBlock(String start_A, String end_A, void body(), {endWithNewline: true}) {
    _addBlock(start_A, end_A, body, endWithNewline, '');
  }
  void _addBlock(String start_A, String end_A, void body(), endWithNewline, newIndent) {
    println(start_A);
    var oldIndent = _indent_A;
    _indent_A = newIndent;
    body();
    _indent_A = oldIndent;
    if (endWithNewline) {
      println(end_A);
    } else {
      print(end_A);
    }
  }
  String toString() => _buffer_C.toString();
  void _writeChunk(String chunk) {
    assert(!chunk.contains('\n'));
    if (chunk.isEmpty) return;
    if (_needIndent) {
      _buffer_C.write(_indent_A);
      _needIndent = false;
    }
    _buffer_C.write(chunk);
  }
  void _newline() {
    _buffer_C.writeln();
    _needIndent = true;
  }
}
void main() {
  new CodeGenerator(_B.stdin, _B.stdout).generate_A();
}