/*eslint-disable block-scoped-var, no-redeclare, no-control-regex, no-prototype-builtins*/

"use strict";

var $protobuf = require("protobufjs/minimal");

var $Reader = $protobuf.Reader, $util = $protobuf.util;

var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});

$root.tensorflow = (function() {

var tensorflow = {};

tensorflow.Any = (function() {

function Any(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

Any.prototype.typeUrl = "";

Any.prototype.value = $util.newBuffer([]);

Any.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.Any();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.typeUrl = r.string();

break;

case 2:

m.value = r.bytes();

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return Any;

})();

tensorflow.DataType = (function() {

var valuesById = {}, values = Object.create(valuesById);

values[valuesById[0] = "DT_INVALID"] = 0;

values[valuesById[1] = "DT_FLOAT"] = 1;

values[valuesById[2] = "DT_DOUBLE"] = 2;

values[valuesById[3] = "DT_INT32"] = 3;

values[valuesById[4] = "DT_UINT8"] = 4;

values[valuesById[5] = "DT_INT16"] = 5;

values[valuesById[6] = "DT_INT8"] = 6;

values[valuesById[7] = "DT_STRING"] = 7;

values[valuesById[8] = "DT_COMPLEX64"] = 8;

values[valuesById[9] = "DT_INT64"] = 9;

values[valuesById[10] = "DT_BOOL"] = 10;

values[valuesById[11] = "DT_QINT8"] = 11;

values[valuesById[12] = "DT_QUINT8"] = 12;

values[valuesById[13] = "DT_QINT32"] = 13;

values[valuesById[14] = "DT_BFLOAT16"] = 14;

values[valuesById[101] = "DT_FLOAT_REF"] = 101;

values[valuesById[102] = "DT_DOUBLE_REF"] = 102;

values[valuesById[103] = "DT_INT32_REF"] = 103;

values[valuesById[104] = "DT_UINT8_REF"] = 104;

values[valuesById[105] = "DT_INT16_REF"] = 105;

values[valuesById[106] = "DT_INT8_REF"] = 106;

values[valuesById[107] = "DT_STRING_REF"] = 107;

values[valuesById[108] = "DT_COMPLEX64_REF"] = 108;

values[valuesById[109] = "DT_INT64_REF"] = 109;

values[valuesById[110] = "DT_BOOL_REF"] = 110;

values[valuesById[111] = "DT_QINT8_REF"] = 111;

values[valuesById[112] = "DT_QUINT8_REF"] = 112;

values[valuesById[113] = "DT_QINT32_REF"] = 113;

values[valuesById[114] = "DT_BFLOAT16_REF"] = 114;

return values;

})();

tensorflow.TensorShape = (function() {

function TensorShape(p) {

this.dim = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

TensorShape.prototype.dim = $util.emptyArray;

TensorShape.prototype.unknownRank = false;

TensorShape.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.TensorShape();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 2:

if (!(m.dim && m.dim.length))

m.dim = [];

m.dim.push($root.tensorflow.TensorShape.Dim.decode(r, r.uint32()));

break;

case 3:

m.unknownRank = r.bool();

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

TensorShape.Dim = (function() {

function Dim(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

Dim.prototype.size = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

Dim.prototype.name = "";

Dim.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.TensorShape.Dim();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.size = r.int64();

break;

case 2:

m.name = r.string();

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return Dim;

})();

return TensorShape;

})();

tensorflow.Tensor = (function() {

function Tensor(p) {

this.floatVal = [];

this.doubleVal = [];

this.intVal = [];

this.stringVal = [];

this.scomplexVal = [];

this.int64Val = [];

this.boolVal = [];

this.uint32Val = [];

this.uint64Val = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

Tensor.prototype.dtype = 0;

Tensor.prototype.tensorShape = null;

Tensor.prototype.versionNumber = 0;

Tensor.prototype.tensorContent = $util.newBuffer([]);

Tensor.prototype.floatVal = $util.emptyArray;

Tensor.prototype.doubleVal = $util.emptyArray;

Tensor.prototype.intVal = $util.emptyArray;

Tensor.prototype.stringVal = $util.emptyArray;

Tensor.prototype.scomplexVal = $util.emptyArray;

Tensor.prototype.int64Val = $util.emptyArray;

Tensor.prototype.boolVal = $util.emptyArray;

Tensor.prototype.uint32Val = $util.emptyArray;

Tensor.prototype.uint64Val = $util.emptyArray;

Tensor.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.Tensor();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.dtype = r.int32();

break;

case 2:

m.tensorShape = $root.tensorflow.TensorShape.decode(r, r.uint32());

break;

case 3:

m.versionNumber = r.int32();

break;

case 4:

m.tensorContent = r.bytes();

break;

case 5:

if (!(m.floatVal && m.floatVal.length))

m.floatVal = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.floatVal.push(r.float());

} else

m.floatVal.push(r.float());

break;

case 6:

if (!(m.doubleVal && m.doubleVal.length))

m.doubleVal = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.doubleVal.push(r.double());

} else

m.doubleVal.push(r.double());

break;

case 7:

if (!(m.intVal && m.intVal.length))

m.intVal = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.intVal.push(r.int32());

} else

m.intVal.push(r.int32());

break;

case 8:

if (!(m.stringVal && m.stringVal.length))

m.stringVal = [];

m.stringVal.push(r.bytes());

break;

case 9:

if (!(m.scomplexVal && m.scomplexVal.length))

m.scomplexVal = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.scomplexVal.push(r.float());

} else

m.scomplexVal.push(r.float());

break;

case 10:

if (!(m.int64Val && m.int64Val.length))

m.int64Val = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.int64Val.push(r.int64());

} else

m.int64Val.push(r.int64());

break;

case 11:

if (!(m.boolVal && m.boolVal.length))

m.boolVal = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.boolVal.push(r.bool());

} else

m.boolVal.push(r.bool());

break;

case 16:

if (!(m.uint32Val && m.uint32Val.length))

m.uint32Val = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.uint32Val.push(r.uint32());

} else

m.uint32Val.push(r.uint32());

break;

case 17:

if (!(m.uint64Val && m.uint64Val.length))

m.uint64Val = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.uint64Val.push(r.uint64());

} else

m.uint64Val.push(r.uint64());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return Tensor;

})();

tensorflow.AttrValue = (function() {

function AttrValue(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

AttrValue.prototype.list = null;

AttrValue.prototype.s = $util.newBuffer([]);

AttrValue.prototype.i = $util.Long ? $util.Long.fromBits(0,0,false) : 0;

AttrValue.prototype.f = 0;

AttrValue.prototype.b = false;

AttrValue.prototype.type = 0;

AttrValue.prototype.shape = null;

AttrValue.prototype.tensor = null;

AttrValue.prototype.placeholder = "";

AttrValue.prototype.func = null;

var $oneOfFields;

Object.defineProperty(AttrValue.prototype, "value", {

get: $util.oneOfGetter($oneOfFields = ["list", "s", "i", "f", "b", "type", "shape", "tensor", "placeholder", "func"]),

set: $util.oneOfSetter($oneOfFields)

});

AttrValue.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.AttrValue();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.list = $root.tensorflow.AttrValue.ListValue.decode(r, r.uint32());

break;

case 2:

m.s = r.bytes();

break;

case 3:

m.i = r.int64();

break;

case 4:

m.f = r.float();

break;

case 5:

m.b = r.bool();

break;

case 6:

m.type = r.int32();

break;

case 7:

m.shape = $root.tensorflow.TensorShape.decode(r, r.uint32());

break;

case 8:

m.tensor = $root.tensorflow.Tensor.decode(r, r.uint32());

break;

case 9:

m.placeholder = r.string();

break;

case 10:

m.func = $root.tensorflow.NameAttrList.decode(r, r.uint32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

AttrValue.ListValue = (function() {

function ListValue(p) {

this.s = [];

this.i = [];

this.f = [];

this.b = [];

this.type = [];

this.shape = [];

this.tensor = [];

this.func = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

ListValue.prototype.s = $util.emptyArray;

ListValue.prototype.i = $util.emptyArray;

ListValue.prototype.f = $util.emptyArray;

ListValue.prototype.b = $util.emptyArray;

ListValue.prototype.type = $util.emptyArray;

ListValue.prototype.shape = $util.emptyArray;

ListValue.prototype.tensor = $util.emptyArray;

ListValue.prototype.func = $util.emptyArray;

ListValue.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.AttrValue.ListValue();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 2:

if (!(m.s && m.s.length))

m.s = [];

m.s.push(r.bytes());

break;

case 3:

if (!(m.i && m.i.length))

m.i = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.i.push(r.int64());

} else

m.i.push(r.int64());

break;

case 4:

if (!(m.f && m.f.length))

m.f = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.f.push(r.float());

} else

m.f.push(r.float());

break;

case 5:

if (!(m.b && m.b.length))

m.b = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.b.push(r.bool());

} else

m.b.push(r.bool());

break;

case 6:

if (!(m.type && m.type.length))

m.type = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.type.push(r.int32());

} else

m.type.push(r.int32());

break;

case 7:

if (!(m.shape && m.shape.length))

m.shape = [];

m.shape.push($root.tensorflow.TensorShape.decode(r, r.uint32()));

break;

case 8:

if (!(m.tensor && m.tensor.length))

m.tensor = [];

m.tensor.push($root.tensorflow.Tensor.decode(r, r.uint32()));

break;

case 9:

if (!(m.func && m.func.length))

m.func = [];

m.func.push($root.tensorflow.NameAttrList.decode(r, r.uint32()));

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return ListValue;

})();

return AttrValue;

})();

tensorflow.NameAttrList = (function() {

function NameAttrList(p) {

this.attr = {};

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

NameAttrList.prototype.name = "";

NameAttrList.prototype.attr = $util.emptyObject;

NameAttrList.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.NameAttrList(), k;

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.name = r.string();

break;

case 2:

r.skip().pos++;

if (m.attr === $util.emptyObject)

m.attr = {};

k = r.string();

r.pos++;

m.attr[k] = $root.tensorflow.AttrValue.decode(r, r.uint32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return NameAttrList;

})();

tensorflow.NodeDef = (function() {

function NodeDef(p) {

this.input = [];

this.attr = {};

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

NodeDef.prototype.name = "";

NodeDef.prototype.op = "";

NodeDef.prototype.input = $util.emptyArray;

NodeDef.prototype.device = "";

NodeDef.prototype.attr = $util.emptyObject;

NodeDef.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.NodeDef(), k;

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.name = r.string();

break;

case 2:

m.op = r.string();

break;

case 3:

if (!(m.input && m.input.length))

m.input = [];

m.input.push(r.string());

break;

case 4:

m.device = r.string();

break;

case 5:

r.skip().pos++;

if (m.attr === $util.emptyObject)

m.attr = {};

k = r.string();

r.pos++;

m.attr[k] = $root.tensorflow.AttrValue.decode(r, r.uint32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return NodeDef;

})();

tensorflow.VersionDef = (function() {

function VersionDef(p) {

this.badConsumers = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

VersionDef.prototype.producer = 0;

VersionDef.prototype.minConsumer = 0;

VersionDef.prototype.badConsumers = $util.emptyArray;

VersionDef.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.VersionDef();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.producer = r.int32();

break;

case 2:

m.minConsumer = r.int32();

break;

case 3:

if (!(m.badConsumers && m.badConsumers.length))

m.badConsumers = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.badConsumers.push(r.int32());

} else

m.badConsumers.push(r.int32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return VersionDef;

})();

tensorflow.GraphDef = (function() {

function GraphDef(p) {

this.node = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

GraphDef.prototype.node = $util.emptyArray;

GraphDef.prototype.versions = null;

GraphDef.prototype.library = null;

GraphDef.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.GraphDef();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.node && m.node.length))

m.node = [];

m.node.push($root.tensorflow.NodeDef.decode(r, r.uint32()));

break;

case 4:

m.versions = $root.tensorflow.VersionDef.decode(r, r.uint32());

break;

case 2:

m.library = $root.tensorflow.FunctionDefLibrary.decode(r, r.uint32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return GraphDef;

})();

tensorflow.CollectionDef = (function() {

function CollectionDef(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

CollectionDef.prototype.nodeList = null;

CollectionDef.prototype.bytesList = null;

CollectionDef.prototype.int64List = null;

CollectionDef.prototype.floatList = null;

CollectionDef.prototype.anyList = null;

var $oneOfFields;

Object.defineProperty(CollectionDef.prototype, "kind", {

get: $util.oneOfGetter($oneOfFields = ["nodeList", "bytesList", "int64List", "floatList", "anyList"]),

set: $util.oneOfSetter($oneOfFields)

});

CollectionDef.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.nodeList = $root.tensorflow.CollectionDef.NodeList.decode(r, r.uint32());

break;

case 2:

m.bytesList = $root.tensorflow.CollectionDef.BytesList.decode(r, r.uint32());

break;

case 3:

m.int64List = $root.tensorflow.CollectionDef.Int64List.decode(r, r.uint32());

break;

case 4:

m.floatList = $root.tensorflow.CollectionDef.FloatList.decode(r, r.uint32());

break;

case 5:

m.anyList = $root.tensorflow.CollectionDef.AnyList.decode(r, r.uint32());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

CollectionDef.NodeList = (function() {

function NodeList(p) {

this.value = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

NodeList.prototype.value = $util.emptyArray;

NodeList.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef.NodeList();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.value && m.value.length))

m.value = [];

m.value.push(r.string());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return NodeList;

})();

CollectionDef.BytesList = (function() {

function BytesList(p) {

this.value = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

BytesList.prototype.value = $util.emptyArray;

BytesList.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef.BytesList();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.value && m.value.length))

m.value = [];

m.value.push(r.bytes());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return BytesList;

})();

CollectionDef.Int64List = (function() {

function Int64List(p) {

this.value = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

Int64List.prototype.value = $util.emptyArray;

Int64List.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef.Int64List();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.value && m.value.length))

m.value = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.value.push(r.int64());

} else

m.value.push(r.int64());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return Int64List;

})();

CollectionDef.FloatList = (function() {

function FloatList(p) {

this.value = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

FloatList.prototype.value = $util.emptyArray;

FloatList.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef.FloatList();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.value && m.value.length))

m.value = [];

if ((t & 7) === 2) {

var c2 = r.uint32() + r.pos;

while (r.pos < c2)

m.value.push(r.float());

} else

m.value.push(r.float());

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return FloatList;

})();

CollectionDef.AnyList = (function() {

function AnyList(p) {

this.value = [];

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

AnyList.prototype.value = $util.emptyArray;

AnyList.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.CollectionDef.AnyList();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

if (!(m.value && m.value.length))

m.value = [];

m.value.push($root.tensorflow.Any.decode(r, r.uint32()));

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

return AnyList;

})();

return CollectionDef;

})();

tensorflow.SaverDef = (function() {

function SaverDef(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

SaverDef.prototype.filenameTensorName = "";

SaverDef.prototype.saveTensorName = "";

SaverDef.prototype.restoreOpName = "";

SaverDef.prototype.maxToKeep = 0;

SaverDef.prototype.sharded = false;

SaverDef.prototype.keepCheckpointEveryNHours = 0;

SaverDef.prototype.version = 0;

SaverDef.decode = function decode(r, l) {

if (!(r instanceof $Reader))

r = $Reader.create(r);

var c = l === undefined ? r.len : r.pos + l, m = new $root.tensorflow.SaverDef();

while (r.pos < c) {

var t = r.uint32();

switch (t >>> 3) {

case 1:

m.filenameTensorName = r.string();

break;

case 2:

m.saveTensorName = r.string();

break;

case 3:

m.restoreOpName = r.string();

break;

case 4:

m.maxToKeep = r.int32();

break;

case 5:

m.sharded = r.bool();

break;

case 6:

m.keepCheckpointEveryNHours = r.float();

break;

case 7:

m.version = r.int32();

break;

default:

r.skipType(t & 7);

break;

}

}

return m;

};

SaverDef.CheckpointFormatVersion = (function() {

var valuesById = {}, values = Object.create(valuesById);

values[valuesById[0] = "LEGACY"] = 0;

values[valuesById[1] = "V1"] = 1;

values[valuesById[2] = "V2"] = 2;

return values;

})();

return SaverDef;

})();

tensorflow.TensorInfo = (function() {

function TensorInfo(p) {

if (p)

for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)

if (p[ks[i]] != null)

this[ks[i]] = p[ks[i]];

}

TensorInfo.prototype.name = "";

TensorInfo.prototype.cooSparse = null;

TensorInfo.prototype.dtype = 0;

TensorInfo.prototype.tensorShape = null;

var $oneOfFields;

Object.defineProperty(TensorInfo.prototype, "encoding", {

get: $util.oneOfGetter($oneOfFields = ["name", "cooSparse"]),

set: $util.oneOfSetter($oneOfFields)

});

TensorInfo.decode = function decode(r, l) {