public DescribeFleetCapacityResult describeFleetCapacity(DescribeFleetCapacityRequest request) {request = beforeClientExecution(request);return executeDescribeFleetCapacity(request);}

public virtual DescribeFleetCapacityResponse DescribeFleetCapacity(DescribeFleetCapacityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetCapacityRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetCapacityResponseUnmarshaller.Instance;return Invoke<DescribeFleetCapacityResponse>(request, options);}

[User] public DescribeFleetCapacityResult describeFleetCapacity(DescribeFleetCapacityRequest request) {request = beforeClientExecution(request);return executeDescribeFleetCapacity(request);}

[Assistant] public virtual DescribeFleetCapacityResponse DescribeFleetCapacity(DescribeFleetCapacityRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetCapacityRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetCapacityResponseUnmarshaller.Instance;return Invoke<DescribeFleetCapacityResponse>(request, options);}


public UploadPackInternalServerErrorException(Throwable why) {initCause(why);}

public UploadPackInternalServerErrorException(Exception why){Sharpen.Extensions.InitCause(this, why);}

[User] public UploadPackInternalServerErrorException(Throwable why) {initCause(why);}

[Assistant] public UploadPackInternalServerErrorException(Exception why){Sharpen.Extensions.InitCause(this, why);}


public GetNetworkResult getNetwork(GetNetworkRequest request) {request = beforeClientExecution(request);return executeGetNetwork(request);}

public virtual GetNetworkResponse GetNetwork(GetNetworkRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetNetworkRequestMarshaller.Instance;options.ResponseUnmarshaller = GetNetworkResponseUnmarshaller.Instance;return Invoke<GetNetworkResponse>(request, options);}

[User] public GetNetworkResult getNetwork(GetNetworkRequest request) {request = beforeClientExecution(request);return executeGetNetwork(request);}

[Assistant] public virtual GetNetworkResponse GetNetwork(GetNetworkRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetNetworkRequestMarshaller.Instance;options.ResponseUnmarshaller = GetNetworkResponseUnmarshaller.Instance;return Invoke<GetNetworkResponse>(request, options);}


public AllocatePrivateVirtualInterfaceResult allocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeAllocatePrivateVirtualInterface(request);}

public virtual AllocatePrivateVirtualInterfaceResponse AllocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocatePrivateVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocatePrivateVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<AllocatePrivateVirtualInterfaceResponse>(request, options);}

[User] public AllocatePrivateVirtualInterfaceResult allocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request) {request = beforeClientExecution(request);return executeAllocatePrivateVirtualInterface(request);}

[Assistant] public virtual AllocatePrivateVirtualInterfaceResponse AllocatePrivateVirtualInterface(AllocatePrivateVirtualInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocatePrivateVirtualInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocatePrivateVirtualInterfaceResponseUnmarshaller.Instance;return Invoke<AllocatePrivateVirtualInterfaceResponse>(request, options);}


public GetDeploymentResult getDeployment(GetDeploymentRequest request) {request = beforeClientExecution(request);return executeGetDeployment(request);}

public virtual GetDeploymentResponse GetDeployment(GetDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDeploymentResponseUnmarshaller.Instance;return Invoke<GetDeploymentResponse>(request, options);}

[User] public GetDeploymentResult getDeployment(GetDeploymentRequest request) {request = beforeClientExecution(request);return executeGetDeployment(request);}

[Assistant] public virtual GetDeploymentResponse GetDeployment(GetDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDeploymentResponseUnmarshaller.Instance;return Invoke<GetDeploymentResponse>(request, options);}


public UpdateRepoAuthorizationRequest(): base("cr", "2016-06-07", "UpdateRepoAuthorization", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]";Method = MethodType.POST;}

[User] public UpdateRepoAuthorizationRequest() {super("cr", "2016-06-07", "UpdateRepoAuthorization", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]");setMethod(MethodType.POST);}

[Assistant] public UpdateRepoAuthorizationRequest(): base("cr", "2016-06-07", "UpdateRepoAuthorization", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/authorizations/[AuthorizeId]";Method = MethodType.POST;}


public void foldToASCII(char[] input, int length){final int maxSizeNeeded = 4 * length;if (output.length < maxSizeNeeded) {output = new char[ArrayUtil.oversize(maxSizeNeeded, Character.BYTES)];}outputPos = foldToASCII(input, 0, output, 0, length);if (preserveOriginal && needToPreserve(input, length)) {state = captureState();}}

public void FoldToASCII(char[] input, int length){if (preserveOriginal){state = CaptureState();}int maxSizeNeeded = 4 * length;if (output.Length < maxSizeNeeded){output = new char[ArrayUtil.Oversize(maxSizeNeeded, RamUsageEstimator.NUM_BYTES_CHAR)];}outputPos = FoldToASCII(input, 0, output, 0, length);}

[User] public void foldToASCII(char[] input, int length){final int maxSizeNeeded = 4 * length;if (output.length < maxSizeNeeded) {output = new char[ArrayUtil.oversize(maxSizeNeeded, Character.BYTES)];}outputPos = foldToASCII(input, 0, output, 0, length);if (preserveOriginal && needToPreserve(input, length)) {state = captureState();}}

[Assistant] public void FoldToASCII(char[] input, int length){if (preserveOriginal){state = CaptureState();}int maxSizeNeeded = 4 * length;if (output.Length < maxSizeNeeded){output = new char[ArrayUtil.Oversize(maxSizeNeeded, RamUsageEstimator.NUM_BYTES_CHAR)];}outputPos = FoldToASCII(input, 0, output, 0, length);}


public boolean hasEntry(String name) {if (excludes.contains(name)) {return false;}return directory.hasEntry(name);}

public bool HasEntry(String name){if (excludes.Contains(name)){return false;}return directory.HasEntry(name);}

[User] public boolean hasEntry(String name) {if (excludes.contains(name)) {return false;}return directory.hasEntry(name);}

[Assistant] public bool HasEntry(String name){if (excludes.Contains(name)){return false;}return directory.HasEntry(name);}


public void setLockMessage(String msg) {lockMessage = msg;}

public virtual void SetLockMessage(string msg){lockMessage = msg;}

[User] public void setLockMessage(String msg) {lockMessage = msg;}

[Assistant] public virtual void SetLockMessage(string msg){lockMessage = msg;}


public ReflogCommand reflog() {return new ReflogCommand(repo);}

public virtual ReflogCommand Reflog(){return new ReflogCommand(repo);}

[User] public ReflogCommand reflog() {return new ReflogCommand(repo);}

[Assistant] public virtual ReflogCommand Reflog(){return new ReflogCommand(repo);}


[User] public void serialize(LittleEndianOutput out) {out.writeShort(getFirstRow());out.writeShort(getLastRow());out.writeShort(getFirstColumn());out.writeShort(getLastColumn());}

[Assistant] public void Serialize(ILittleEndianOutput out1){out1.WriteShort(FirstRow);out1.WriteShort(LastRow);out1.WriteShort(FirstColumn);out1.WriteShort(LastColumn);}


public static int response(java.net.HttpURLConnection c)throws IOException {try {return c.getResponseCode();} catch (ConnectException ce) {final URL url = c.getURL();final String host = (url == null) ? "<null>" : url.getHost(); if ("Connection timed out: connect".equals(ce.getMessage())) throw new ConnectException(MessageFormat.format(JGitText.get().connectionTimeOut, host));throw new ConnectException(ce.getMessage() + " " + host); }}

public static int Response(HttpURLConnection c){try{return c.GetResponseCode();}catch (ConnectException ce){string host = c.GetURL().GetHost();if ("Connection timed out: connect".Equals(ce.Message)){throw new ConnectException(MessageFormat.Format(JGitText.Get().connectionTimeOut,host));}throw new ConnectException(ce.Message + " " + host);}}

[User] public static int response(java.net.HttpURLConnection c)throws IOException {try {return c.getResponseCode();} catch (ConnectException ce) {final URL url = c.getURL();final String host = (url == null) ? "<null>" : url.getHost(); if ("Connection timed out: connect".equals(ce.getMessage())) throw new ConnectException(MessageFormat.format(JGitText.get().connectionTimeOut, host));throw new ConnectException(ce.getMessage() + " " + host); }}

[Assistant] public static int Response(HttpURLConnection c){try{return c.GetResponseCode();}catch (ConnectException ce){string host = c.GetURL().GetHost();if ("Connection timed out: connect".Equals(ce.Message)){throw new ConnectException(MessageFormat.Format(JGitText.Get().connectionTimeOut,host));}throw new ConnectException(ce.Message + " " + host);}}


public static void fill(long[] array, long value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}

public static void fill(long[] array, long value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}

[User] public static void fill(long[] array, long value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}

[Assistant] public static void fill(long[] array, long value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}


public void serialize(LittleEndianOutput out) {out.writeInt(getPositionOfBof());out.writeShort(field_2_option_flags);String name = field_5_sheetname;out.writeByte(name.length());out.writeByte(field_4_isMultibyteUnicode);if (isMultibyte()) {StringUtil.putUnicodeLE(name, out);} else {StringUtil.putCompressedUnicode(name, out);}}

public override void Serialize(ILittleEndianOutput out1){out1.WriteInt(PositionOfBof);out1.WriteShort(field_2_option_flags);String name = field_5_sheetname;out1.WriteByte(name.Length);out1.WriteByte(field_4_isMultibyteUnicode);if (IsMultibyte){StringUtil.PutUnicodeLE(name, out1);}else{StringUtil.PutCompressedUnicode(name, out1);}}

[User] public void serialize(LittleEndianOutput out) {out.writeInt(getPositionOfBof());out.writeShort(field_2_option_flags);String name = field_5_sheetname;out.writeByte(name.length());out.writeByte(field_4_isMultibyteUnicode);if (isMultibyte()) {StringUtil.putUnicodeLE(name, out);} else {StringUtil.putCompressedUnicode(name, out);}}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteInt(PositionOfBof);out1.WriteShort(field_2_option_flags);String name = field_5_sheetname;out1.WriteByte(name.Length);out1.WriteByte(field_4_isMultibyteUnicode);if (IsMultibyte){StringUtil.PutUnicodeLE(name, out1);}else{StringUtil.PutCompressedUnicode(name, out1);}}


public static String getNonBlankTextOrFail(Element e) throws ParserException {String v = getText(e);if (null != v)v = v.trim();if (null == v || 0 == v.length()) {throw new ParserException(e.getTagName() + " has no text");}return v;}

public static string GetNonBlankTextOrFail(XmlElement e){string v = GetText(e);if (null != v)v = v.Trim();if (null == v || 0 == v.Length){throw new ParserException(e.ToString() + " has no text");}return v;}

[User] public static String getNonBlankTextOrFail(Element e) throws ParserException {String v = getText(e);if (null != v)v = v.trim();if (null == v || 0 == v.length()) {throw new ParserException(e.getTagName() + " has no text");}return v;}

[Assistant] public static string GetNonBlankTextOrFail(XmlElement e){string v = GetText(e);if (null != v)v = v.Trim();if (null == v || 0 == v.Length){throw new ParserException(e.ToString() + " has no text");}return v;}


public void buildFieldConfig(FieldConfig fieldConfig) {Map<String, Float> fieldBoostMap = this.config.get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null) {Float boost = fieldBoostMap.get(fieldConfig.getField());if (boost != null) {fieldConfig.set(ConfigurationKeys.BOOST, boost);}}}

public virtual void BuildFieldConfig(FieldConfig fieldConfig){IDictionary<string, float?> fieldBoostMap = this.config.Get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null){float? boost;if (fieldBoostMap.TryGetValue(fieldConfig.Field, out boost) && boost != null){fieldConfig.Set(ConfigurationKeys.BOOST, boost);}}}

[User] public void buildFieldConfig(FieldConfig fieldConfig) {Map<String, Float> fieldBoostMap = this.config.get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null) {Float boost = fieldBoostMap.get(fieldConfig.getField());if (boost != null) {fieldConfig.set(ConfigurationKeys.BOOST, boost);}}}

[Assistant] public virtual void BuildFieldConfig(FieldConfig fieldConfig){IDictionary<string, float?> fieldBoostMap = this.config.Get(ConfigurationKeys.FIELD_BOOST_MAP);if (fieldBoostMap != null){float? boost;if (fieldBoostMap.TryGetValue(fieldConfig.Field, out boost) && boost != null){fieldConfig.Set(ConfigurationKeys.BOOST, boost);}}}


public PutLifecyclePolicyResult putLifecyclePolicy(PutLifecyclePolicyRequest request) {request = beforeClientExecution(request);return executePutLifecyclePolicy(request);}

public virtual PutLifecyclePolicyResponse PutLifecyclePolicy(PutLifecyclePolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutLifecyclePolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutLifecyclePolicyResponseUnmarshaller.Instance;return Invoke<PutLifecyclePolicyResponse>(request, options);}

[User] public PutLifecyclePolicyResult putLifecyclePolicy(PutLifecyclePolicyRequest request) {request = beforeClientExecution(request);return executePutLifecyclePolicy(request);}

[Assistant] public virtual PutLifecyclePolicyResponse PutLifecyclePolicy(PutLifecyclePolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutLifecyclePolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = PutLifecyclePolicyResponseUnmarshaller.Instance;return Invoke<PutLifecyclePolicyResponse>(request, options);}


public SortedSet<E> subSet(E start, E end) {return subSet(start, true, end, false);}

public virtual java.util.SortedSet<E> subSet(E start, E end){return subSet(start, true, end, false);}

[User] public SortedSet<E> subSet(E start, E end) {return subSet(start, true, end, false);}

[Assistant] public virtual java.util.SortedSet<E> subSet(E start, E end){return subSet(start, true, end, false);}


public void setParams(String params) {super.setParams(params);if (params != null) {int multiplier;if (params.endsWith("s")) {multiplier = 1;params = params.substring(0, params.length()-1);} else if (params.endsWith("m")) {multiplier = 60;params = params.substring(0, params.length()-1);} else if (params.endsWith("h")) {multiplier = 3600;params = params.substring(0, params.length()-1);} else {multiplier = 1;}waitTimeSec = Double.parseDouble(params) * multiplier;} else {throw new IllegalArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}

public override void SetParams(string @params){base.SetParams(@params);if (@params != null){int multiplier;if (@params.EndsWith("s", StringComparison.Ordinal)){multiplier = 1;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("m", StringComparison.Ordinal)){multiplier = 60;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("h", StringComparison.Ordinal)){multiplier = 3600;@params = @params.Substring(0, @params.Length - 1);}else{multiplier = 1;}waitTimeSec = double.Parse(@params, CultureInfo.InvariantCulture) * multiplier;}else{throw new ArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}

[User] public void setParams(String params) {super.setParams(params);if (params != null) {int multiplier;if (params.endsWith("s")) {multiplier = 1;params = params.substring(0, params.length()-1);} else if (params.endsWith("m")) {multiplier = 60;params = params.substring(0, params.length()-1);} else if (params.endsWith("h")) {multiplier = 3600;params = params.substring(0, params.length()-1);} else {multiplier = 1;}waitTimeSec = Double.parseDouble(params) * multiplier;} else {throw new IllegalArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}

[Assistant] public override void SetParams(string @params){base.SetParams(@params);if (@params != null){int multiplier;if (@params.EndsWith("s", StringComparison.Ordinal)){multiplier = 1;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("m", StringComparison.Ordinal)){multiplier = 60;@params = @params.Substring(0, @params.Length - 1);}else if (@params.EndsWith("h", StringComparison.Ordinal)){multiplier = 3600;@params = @params.Substring(0, @params.Length - 1);}else{multiplier = 1;}waitTimeSec = double.Parse(@params, CultureInfo.InvariantCulture) * multiplier;}else{throw new ArgumentException("you must specify the wait time, eg: 10.0s, 4.5m, 2h");}}


public PutAttributesRequest(String domainName, String itemName, java.util.List<ReplaceableAttribute> attributes, UpdateCondition expected) {setDomainName(domainName);setItemName(itemName);setAttributes(attributes);setExpected(expected);}

public PutAttributesRequest(string domainName, string itemName, List<ReplaceableAttribute> attributes, UpdateCondition expected){_domainName = domainName;_itemName = itemName;_attributes = attributes;_expected = expected;}

[User] public PutAttributesRequest(String domainName, String itemName, java.util.List<ReplaceableAttribute> attributes, UpdateCondition expected) {setDomainName(domainName);setItemName(itemName);setAttributes(attributes);setExpected(expected);}

[Assistant] public PutAttributesRequest(string domainName, string itemName, List<ReplaceableAttribute> attributes, UpdateCondition expected){_domainName = domainName;_itemName = itemName;_attributes = attributes;_expected = expected;}


public DescribeStreamConsumerResult describeStreamConsumer(DescribeStreamConsumerRequest request) {request = beforeClientExecution(request);return executeDescribeStreamConsumer(request);}

public virtual DescribeStreamConsumerResponse DescribeStreamConsumer(DescribeStreamConsumerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStreamConsumerRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStreamConsumerResponseUnmarshaller.Instance;return Invoke<DescribeStreamConsumerResponse>(request, options);}

[User] public DescribeStreamConsumerResult describeStreamConsumer(DescribeStreamConsumerRequest request) {request = beforeClientExecution(request);return executeDescribeStreamConsumer(request);}

[Assistant] public virtual DescribeStreamConsumerResponse DescribeStreamConsumer(DescribeStreamConsumerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeStreamConsumerRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeStreamConsumerResponseUnmarshaller.Instance;return Invoke<DescribeStreamConsumerResponse>(request, options);}


public void freeze() {this.frozen = true;}

public virtual void Freeze(){this.frozen = true;}

[User] public void freeze() {this.frozen = true;}

[Assistant] public virtual void Freeze(){this.frozen = true;}


public FuzzyLikeThisQueryBuilder(Analyzer analyzer) {this.analyzer = analyzer;}

public FuzzyLikeThisQueryBuilder(Analyzer analyzer){this.analyzer = analyzer;}

[User] public FuzzyLikeThisQueryBuilder(Analyzer analyzer) {this.analyzer = analyzer;}

[Assistant] public FuzzyLikeThisQueryBuilder(Analyzer analyzer){this.analyzer = analyzer;}


public DBClusterSnapshot copyDBClusterSnapshot(CopyDBClusterSnapshotRequest request) {request = beforeClientExecution(request);return executeCopyDBClusterSnapshot(request);}

public virtual CopyDBClusterSnapshotResponse CopyDBClusterSnapshot(CopyDBClusterSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyDBClusterSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyDBClusterSnapshotResponseUnmarshaller.Instance;return Invoke<CopyDBClusterSnapshotResponse>(request, options);}

[User] public DBClusterSnapshot copyDBClusterSnapshot(CopyDBClusterSnapshotRequest request) {request = beforeClientExecution(request);return executeCopyDBClusterSnapshot(request);}

[Assistant] public virtual CopyDBClusterSnapshotResponse CopyDBClusterSnapshot(CopyDBClusterSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyDBClusterSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyDBClusterSnapshotResponseUnmarshaller.Instance;return Invoke<CopyDBClusterSnapshotResponse>(request, options);}


public OutputStreamDataOutput(OutputStream os) {this.os = os;}

public OutputStreamDataOutput(Stream os){this._writer = new BinaryWriter(os);}

[User] public OutputStreamDataOutput(OutputStream os) {this.os = os;}

[Assistant] public OutputStreamDataOutput(Stream os){this._writer = new BinaryWriter(os);}


public String findPattern(String pat) {int k = super.find(pat);if (k >= 0) {return unpackValues(k);}return "";}

public virtual string FindPattern(string pat){int k = base.Find(pat);if (k >= 0){return UnpackValues(k);}return "";}

[User] public String findPattern(String pat) {int k = super.find(pat);if (k >= 0) {return unpackValues(k);}return "";}

[Assistant] public virtual string FindPattern(string pat){int k = base.Find(pat);if (k >= 0){return UnpackValues(k);}return "";}


public static int murmurhash3_x86_32(BytesRef bytes, int seed) {return murmurhash3_x86_32(bytes.bytes, bytes.offset, bytes.length, seed);}

public static int Murmurhash3_x86_32(BytesRef bytes, int seed){return Murmurhash3_x86_32(bytes.Bytes, bytes.Offset, bytes.Length, seed);}

[User] public static int murmurhash3_x86_32(BytesRef bytes, int seed) {return murmurhash3_x86_32(bytes.bytes, bytes.offset, bytes.length, seed);}

[Assistant] public static int Murmurhash3_x86_32(BytesRef bytes, int seed){return Murmurhash3_x86_32(bytes.Bytes, bytes.Offset, bytes.Length, seed);}


public boolean isOverridable() {return overridable;}

public virtual bool IsOverridable(){return overridable;}

[User] public boolean isOverridable() {return overridable;}

[Assistant] public virtual bool IsOverridable(){return overridable;}


public UpdateMemberResult updateMember(UpdateMemberRequest request) {request = beforeClientExecution(request);return executeUpdateMember(request);}

public virtual UpdateMemberResponse UpdateMember(UpdateMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMemberResponseUnmarshaller.Instance;return Invoke<UpdateMemberResponse>(request, options);}

[User] public UpdateMemberResult updateMember(UpdateMemberRequest request) {request = beforeClientExecution(request);return executeUpdateMember(request);}

[Assistant] public virtual UpdateMemberResponse UpdateMember(UpdateMemberRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateMemberRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateMemberResponseUnmarshaller.Instance;return Invoke<UpdateMemberResponse>(request, options);}


public CopyFpgaImageResult copyFpgaImage(CopyFpgaImageRequest request) {request = beforeClientExecution(request);return executeCopyFpgaImage(request);}

public virtual CopyFpgaImageResponse CopyFpgaImage(CopyFpgaImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance;return Invoke<CopyFpgaImageResponse>(request, options);}

[User] public CopyFpgaImageResult copyFpgaImage(CopyFpgaImageRequest request) {request = beforeClientExecution(request);return executeCopyFpgaImage(request);}

[Assistant] public virtual CopyFpgaImageResponse CopyFpgaImage(CopyFpgaImageRequest request){var options = new InvokeOptions();options.RequestMarshaller = CopyFpgaImageRequestMarshaller.Instance;options.ResponseUnmarshaller = CopyFpgaImageResponseUnmarshaller.Instance;return Invoke<CopyFpgaImageResponse>(request, options);}


public void inform(ResourceLoader loader) {try { OpenNLPOpsFactory.getPOSTaggerModel(posTaggerModelFile, loader);} catch (IOException e) {throw new IllegalArgumentException(e);}}

public virtual void Inform(IResourceLoader loader){try{ OpenNLPOpsFactory.GetPOSTaggerModel(posTaggerModelFile, loader);}catch (IOException e){throw new ArgumentException(e.ToString(), e);}}

[User] public void inform(ResourceLoader loader) {try { OpenNLPOpsFactory.getPOSTaggerModel(posTaggerModelFile, loader);} catch (IOException e) {throw new IllegalArgumentException(e);}}

[Assistant] public virtual void Inform(IResourceLoader loader){try{ OpenNLPOpsFactory.GetPOSTaggerModel(posTaggerModelFile, loader);}catch (IOException e){throw new ArgumentException(e.ToString(), e);}}


public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol) {super(firstRow, lastRow, firstCol, lastCol);if (lastRow < firstRow || lastCol < firstCol) {throw new IllegalArgumentException("Invalid cell range, having lastRow < firstRow || lastCol < firstCol, " +"had rows " + lastRow + " >= " + firstRow + " or cells " + lastCol + " >= " + firstCol);}}

public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol): base(firstRow, lastRow, firstCol, lastCol){if (lastRow < firstRow || lastCol < firstCol)throw new ArgumentException("lastRow < firstRow || lastCol < firstCol");}

[User] public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol) {super(firstRow, lastRow, firstCol, lastCol);if (lastRow < firstRow || lastCol < firstCol) {throw new IllegalArgumentException("Invalid cell range, having lastRow < firstRow || lastCol < firstCol, " +"had rows " + lastRow + " >= " + firstRow + " or cells " + lastCol + " >= " + firstCol);}}

[Assistant] public CellRangeAddress(int firstRow, int lastRow, int firstCol, int lastCol): base(firstRow, lastRow, firstCol, lastCol){if (lastRow < firstRow || lastCol < firstCol)throw new ArgumentException("lastRow < firstRow || lastCol < firstCol");}


public boolean equals(ATNConfig a, ATNConfig b) {if ( a==b ) return true;if ( a==null || b==null ) return false;return a.state.stateNumber==b.state.stateNumber&& a.context.equals(b.context);}

public override bool Equals(ATNConfig a, ATNConfig b){if (a == b){return true;}if (a == null || b == null){return false;}return a.state.stateNumber == b.state.stateNumber && a.context.Equals(b.context);}

[User] public boolean equals(ATNConfig a, ATNConfig b) {if ( a==b ) return true;if ( a==null || b==null ) return false;return a.state.stateNumber==b.state.stateNumber&& a.context.equals(b.context);}

[Assistant] public override bool Equals(ATNConfig a, ATNConfig b){if (a == b){return true;}if (a == null || b == null){return false;}return a.state.stateNumber == b.state.stateNumber && a.context.Equals(b.context);}


public PushCommand setPushTags() {refSpecs.add(Transport.REFSPEC_TAGS);return this;}

public virtual NGit.Api.PushCommand SetPushTags(){refSpecs.AddItem(NGit.Transport.Transport.REFSPEC_TAGS);return this;}

[User] public PushCommand setPushTags() {refSpecs.add(Transport.REFSPEC_TAGS);return this;}

[Assistant] public virtual NGit.Api.PushCommand SetPushTags(){refSpecs.AddItem(NGit.Transport.Transport.REFSPEC_TAGS);return this;}


public CreateEvaluationResult createEvaluation(CreateEvaluationRequest request) {request = beforeClientExecution(request);return executeCreateEvaluation(request);}

public virtual CreateEvaluationResponse CreateEvaluation(CreateEvaluationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEvaluationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEvaluationResponseUnmarshaller.Instance;return Invoke<CreateEvaluationResponse>(request, options);}

[User] public CreateEvaluationResult createEvaluation(CreateEvaluationRequest request) {request = beforeClientExecution(request);return executeCreateEvaluation(request);}

[Assistant] public virtual CreateEvaluationResponse CreateEvaluation(CreateEvaluationRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateEvaluationRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateEvaluationResponseUnmarshaller.Instance;return Invoke<CreateEvaluationResponse>(request, options);}


public DescribeOrderableDBInstanceOptionsResult describeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeOrderableDBInstanceOptions(request);}

public virtual DescribeOrderableDBInstanceOptionsResponse DescribeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeOrderableDBInstanceOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeOrderableDBInstanceOptionsResponseUnmarshaller.Instance;return Invoke<DescribeOrderableDBInstanceOptionsResponse>(request, options);}

[User] public DescribeOrderableDBInstanceOptionsResult describeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeOrderableDBInstanceOptions(request);}

[Assistant] public virtual DescribeOrderableDBInstanceOptionsResponse DescribeOrderableDBInstanceOptions(DescribeOrderableDBInstanceOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeOrderableDBInstanceOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeOrderableDBInstanceOptionsResponseUnmarshaller.Instance;return Invoke<DescribeOrderableDBInstanceOptionsResponse>(request, options);}


public long getPosition() {return (long) currentBlockIndex * blockSize + currentBlockUpto;}

public long GetPosition(){return (long)currentBlockIndex * outerInstance.blockSize + currentBlockUpto;}

[User] public long getPosition() {return (long) currentBlockIndex * blockSize + currentBlockUpto;}

[Assistant] public long GetPosition(){return (long)currentBlockIndex * outerInstance.blockSize + currentBlockUpto;}


public TokenStream create(TokenStream input) {return new FrenchLightStemFilter(input);}

public override TokenStream Create(TokenStream input){return new FrenchLightStemFilter(input);}

[User] public TokenStream create(TokenStream input) {return new FrenchLightStemFilter(input);}

[Assistant] public override TokenStream Create(TokenStream input){return new FrenchLightStemFilter(input);}


public AssignPrivateIpAddressesResult assignPrivateIpAddresses(AssignPrivateIpAddressesRequest request) {request = beforeClientExecution(request);return executeAssignPrivateIpAddresses(request);}

public virtual AssignPrivateIpAddressesResponse AssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance;options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance;return Invoke<AssignPrivateIpAddressesResponse>(request, options);}

[User] public AssignPrivateIpAddressesResult assignPrivateIpAddresses(AssignPrivateIpAddressesRequest request) {request = beforeClientExecution(request);return executeAssignPrivateIpAddresses(request);}

[Assistant] public virtual AssignPrivateIpAddressesResponse AssignPrivateIpAddresses(AssignPrivateIpAddressesRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssignPrivateIpAddressesRequestMarshaller.Instance;options.ResponseUnmarshaller = AssignPrivateIpAddressesResponseUnmarshaller.Instance;return Invoke<AssignPrivateIpAddressesResponse>(request, options);}


public boolean setExecute(File f, boolean canExec) {return false;}

public override bool SetExecute(FilePath f, bool canExec){return false;}

[User] public boolean setExecute(File f, boolean canExec) {return false;}

[Assistant] public override bool SetExecute(FilePath f, bool canExec){return false;}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup) {try {ValueEval lookupValue = OperandResolver.getSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.resolveTableArrayArg(table_array);boolean isRangeLookup;try {isRangeLookup = LookupUtils.resolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);} catch(RuntimeException e) {isRangeLookup = true;}int rowIndex = LookupUtils.lookupIndexOfValue(lookupValue, LookupUtils.createColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.resolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = createResultColumnVector(tableArray, colIndex);return resultCol.getItem(rowIndex);} catch (EvaluationException e) {return e.getErrorEval();}}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup){try{ValueEval lookupValue = OperandResolver.GetSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.ResolveTableArrayArg(table_array);bool isRangeLookup = LookupUtils.ResolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);int rowIndex = LookupUtils.LookupIndexOfValue(lookupValue, LookupUtils.CreateColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.ResolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = CreateResultColumnVector(tableArray, colIndex);return resultCol.GetItem(rowIndex);}catch (EvaluationException e){return e.GetErrorEval();}}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup) {try {ValueEval lookupValue = OperandResolver.getSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.resolveTableArrayArg(table_array);boolean isRangeLookup;try {isRangeLookup = LookupUtils.resolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);} catch(RuntimeException e) {isRangeLookup = true;}int rowIndex = LookupUtils.lookupIndexOfValue(lookupValue, LookupUtils.createColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.resolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = createResultColumnVector(tableArray, colIndex);return resultCol.getItem(rowIndex);} catch (EvaluationException e) {return e.getErrorEval();}}

[Assistant] public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval lookup_value, ValueEval table_array,ValueEval col_index, ValueEval range_lookup){try{ValueEval lookupValue = OperandResolver.GetSingleValue(lookup_value, srcRowIndex, srcColumnIndex);TwoDEval tableArray = LookupUtils.ResolveTableArrayArg(table_array);bool isRangeLookup = LookupUtils.ResolveRangeLookupArg(range_lookup, srcRowIndex, srcColumnIndex);int rowIndex = LookupUtils.LookupIndexOfValue(lookupValue, LookupUtils.CreateColumnVector(tableArray, 0), isRangeLookup);int colIndex = LookupUtils.ResolveRowOrColIndexArg(col_index, srcRowIndex, srcColumnIndex);ValueVector resultCol = CreateResultColumnVector(tableArray, colIndex);return resultCol.GetItem(rowIndex);}catch (EvaluationException e){return e.GetErrorEval();}}


public CreateGameSessionResult createGameSession(CreateGameSessionRequest request) {request = beforeClientExecution(request);return executeCreateGameSession(request);}

public virtual CreateGameSessionResponse CreateGameSession(CreateGameSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGameSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGameSessionResponseUnmarshaller.Instance;return Invoke<CreateGameSessionResponse>(request, options);}

[User] public CreateGameSessionResult createGameSession(CreateGameSessionRequest request) {request = beforeClientExecution(request);return executeCreateGameSession(request);}

[Assistant] public virtual CreateGameSessionResponse CreateGameSession(CreateGameSessionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGameSessionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGameSessionResponseUnmarshaller.Instance;return Invoke<CreateGameSessionResponse>(request, options);}


public RowRecord getRow(int rowIndex) {int maxrow = SpreadsheetVersion.EXCEL97.getLastRowIndex();if (rowIndex < 0 || rowIndex > maxrow) {throw new IllegalArgumentException("The row number must be between 0 and " + maxrow + ", but had: " + rowIndex);}return _rowRecords.get(Integer.valueOf(rowIndex));}

public RowRecord GetRow(int rowIndex){if (rowIndex < 0 || rowIndex > 65535){throw new ArgumentException("The row number must be between 0 and 65535");}return (RowRecord)_rowRecords[rowIndex];}

[User] public RowRecord getRow(int rowIndex) {int maxrow = SpreadsheetVersion.EXCEL97.getLastRowIndex();if (rowIndex < 0 || rowIndex > maxrow) {throw new IllegalArgumentException("The row number must be between 0 and " + maxrow + ", but had: " + rowIndex);}return _rowRecords.get(Integer.valueOf(rowIndex));}

[Assistant] public RowRecord GetRow(int rowIndex){if (rowIndex < 0 || rowIndex > 65535){throw new ArgumentException("The row number must be between 0 and 65535");}return (RowRecord)_rowRecords[rowIndex];}


public DescribeClientPropertiesResult describeClientProperties(DescribeClientPropertiesRequest request) {request = beforeClientExecution(request);return executeDescribeClientProperties(request);}

public virtual DescribeClientPropertiesResponse DescribeClientProperties(DescribeClientPropertiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClientPropertiesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClientPropertiesResponseUnmarshaller.Instance;return Invoke<DescribeClientPropertiesResponse>(request, options);}

[User] public DescribeClientPropertiesResult describeClientProperties(DescribeClientPropertiesRequest request) {request = beforeClientExecution(request);return executeDescribeClientProperties(request);}

[Assistant] public virtual DescribeClientPropertiesResponse DescribeClientProperties(DescribeClientPropertiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeClientPropertiesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeClientPropertiesResponseUnmarshaller.Instance;return Invoke<DescribeClientPropertiesResponse>(request, options);}


public Builder(CompositeReader reader) {this.reader = reader;}

public Builder(CompositeReader reader){this.reader = reader;}

[User] public Builder(CompositeReader reader) {this.reader = reader;}

[Assistant] public Builder(CompositeReader reader){this.reader = reader;}


public synchronized void mark(int readlimit) {in.mark(readlimit);}

public override void mark(int readlimit){lock (this){@in.mark(readlimit);}}

[User] public synchronized void mark(int readlimit) {in.mark(readlimit);}

[Assistant] public override void mark(int readlimit){lock (this){@in.mark(readlimit);}}


public void print(int inum) {print(String.valueOf(inum));}

public virtual void print(int inum){print(inum.ToString());}

[User] public void print(int inum) {print(String.valueOf(inum));}

[Assistant] public virtual void print(int inum){print(inum.ToString());}


public static final ObjectId fromRaw(int[] is) {return fromRaw(is, 0);}

public static NGit.ObjectId FromRaw(int[] @is){return FromRaw(@is, 0);}

[User] public static final ObjectId fromRaw(int[] is) {return fromRaw(is, 0);}

[Assistant] public static NGit.ObjectId FromRaw(int[] @is){return FromRaw(@is, 0);}


public String toString() {return slice.toString()+":"+ postingsEnum;}

public override string ToString(){return Slice.ToString() + ":" + DocsEnum;}

[User] public String toString() {return slice.toString()+":"+ postingsEnum;}

[Assistant] public override string ToString(){return Slice.ToString() + ":" + DocsEnum;}


public void serialize(LittleEndianOutput out) {out.writeShort(getMode());}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Mode);}

[User] public void serialize(LittleEndianOutput out) {out.writeShort(getMode());}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Mode);}


@Override public int size() {return Impl.this.size();}

public override int size(){return this._enclosing.size();}

[User] @Override public int size() {return Impl.this.size();}

[Assistant] public override int size(){return this._enclosing.size();}


public static int hashCode(Object... objects) {return Arrays.hashCode(objects);}

public static int hashCode(object o){return (o == null) ? 0 : o.GetHashCode();}

[User] public static int hashCode(Object... objects) {return Arrays.hashCode(objects);}

[Assistant] public static int hashCode(object o){return (o == null) ? 0 : o.GetHashCode();}


public ByteBuffer putFloat(int index, float value) {throw new ReadOnlyBufferException();}

public override java.nio.ByteBuffer putFloat(int index, float value){throw new java.nio.ReadOnlyBufferException();}

[User] public ByteBuffer putFloat(int index, float value) {throw new ReadOnlyBufferException();}

[Assistant] public override java.nio.ByteBuffer putFloat(int index, float value){throw new java.nio.ReadOnlyBufferException();}


public ListJournalS3ExportsForLedgerResult listJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request) {request = beforeClientExecution(request);return executeListJournalS3ExportsForLedger(request);}

public virtual ListJournalS3ExportsForLedgerResponse ListJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJournalS3ExportsForLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJournalS3ExportsForLedgerResponseUnmarshaller.Instance;return Invoke<ListJournalS3ExportsForLedgerResponse>(request, options);}

[User] public ListJournalS3ExportsForLedgerResult listJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request) {request = beforeClientExecution(request);return executeListJournalS3ExportsForLedger(request);}

[Assistant] public virtual ListJournalS3ExportsForLedgerResponse ListJournalS3ExportsForLedger(ListJournalS3ExportsForLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListJournalS3ExportsForLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = ListJournalS3ExportsForLedgerResponseUnmarshaller.Instance;return Invoke<ListJournalS3ExportsForLedgerResponse>(request, options);}


public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest request) {request = beforeClientExecution(request);return executeDeleteMessageBatch(request);}

public virtual DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMessageBatchResponseUnmarshaller.Instance;return Invoke<DeleteMessageBatchResponse>(request, options);}

[User] public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest request) {request = beforeClientExecution(request);return executeDeleteMessageBatch(request);}

[Assistant] public virtual DeleteMessageBatchResponse DeleteMessageBatch(DeleteMessageBatchRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteMessageBatchRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteMessageBatchResponseUnmarshaller.Instance;return Invoke<DeleteMessageBatchResponse>(request, options);}


public final void write(LittleEndianOutput out) {out.writeByte(getSid() + getPtgClass());writeCoordinates(out);}

public override void Write(ILittleEndianOutput out1){out1.WriteByte(Sid + PtgClass);WriteCoordinates(out1);}

[User] public final void write(LittleEndianOutput out) {out.writeByte(getSid() + getPtgClass());writeCoordinates(out);}

[Assistant] public override void Write(ILittleEndianOutput out1){out1.WriteByte(Sid + PtgClass);WriteCoordinates(out1);}


public FSTCompletionBuilder(int buckets, BytesRefSorter sorter, int shareMaxTailLength) {if (buckets < 1 || buckets > 255) {throw new IllegalArgumentException("Buckets must be >= 1 and <= 255: "+ buckets);}if (sorter == null) throw new IllegalArgumentException("BytesRefSorter must not be null.");this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}

public FSTCompletionBuilder(int buckets, IBytesRefSorter sorter, int shareMaxTailLength){if (buckets < 1 || buckets > 255){throw new System.ArgumentException("Buckets must be >= 1 and <= 255: " + buckets);}if (sorter == null){throw new System.ArgumentException("BytesRefSorter must not be null.");}this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}

[User] public FSTCompletionBuilder(int buckets, BytesRefSorter sorter, int shareMaxTailLength) {if (buckets < 1 || buckets > 255) {throw new IllegalArgumentException("Buckets must be >= 1 and <= 255: "+ buckets);}if (sorter == null) throw new IllegalArgumentException("BytesRefSorter must not be null.");this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}

[Assistant] public FSTCompletionBuilder(int buckets, IBytesRefSorter sorter, int shareMaxTailLength){if (buckets < 1 || buckets > 255){throw new System.ArgumentException("Buckets must be >= 1 and <= 255: " + buckets);}if (sorter == null){throw new System.ArgumentException("BytesRefSorter must not be null.");}this.sorter = sorter;this.buckets = buckets;this.shareMaxTailLength = shareMaxTailLength;}


public void incRef() {refCount.incrementAndGet();}

public virtual void IncRef(){refCount.IncrementAndGet();}

[User] public void incRef() {refCount.incrementAndGet();}

[Assistant] public virtual void IncRef(){refCount.IncrementAndGet();}


public boolean supports(CredentialItem... items) {for (CredentialItem i : items) {if (i instanceof CredentialItem.Username)continue;else if (i instanceof CredentialItem.Password)continue;elsereturn false;}return true;}

public override bool Supports(params CredentialItem[] items){foreach (CredentialItem i in items){if (i is CredentialItem.Username){continue;}else{if (i is CredentialItem.Password){continue;}else{return false;}}}return true;}

[User] public boolean supports(CredentialItem... items) {for (CredentialItem i : items) {if (i instanceof CredentialItem.Username)continue;else if (i instanceof CredentialItem.Password)continue;elsereturn false;}return true;}

[Assistant] public override bool Supports(params CredentialItem[] items){foreach (CredentialItem i in items){if (i is CredentialItem.Username){continue;}else{if (i is CredentialItem.Password){continue;}else{return false;}}}return true;}


public DeleteVpnConnectionRequest(String vpnConnectionId) {setVpnConnectionId(vpnConnectionId);}

public DeleteVpnConnectionRequest(string vpnConnectionId){_vpnConnectionId = vpnConnectionId;}

[User] public DeleteVpnConnectionRequest(String vpnConnectionId) {setVpnConnectionId(vpnConnectionId);}

[Assistant] public DeleteVpnConnectionRequest(string vpnConnectionId){_vpnConnectionId = vpnConnectionId;}


public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 4) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}

public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 4){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}

[User] public final ValueEval evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex) {if (args.length != 4) {return ErrorEval.VALUE_INVALID;}return evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}

[Assistant] public ValueEval Evaluate(ValueEval[] args, int srcRowIndex, int srcColumnIndex){if (args.Length != 4){return ErrorEval.VALUE_INVALID;}return Evaluate(srcRowIndex, srcColumnIndex, args[0], args[1], args[2], args[3]);}


public void print(double d) {print(String.valueOf(d));}

public virtual void print(double d){print(d.ToString());}

[User] public void print(double d) {print(String.valueOf(d));}

[Assistant] public virtual void print(double d){print(d.ToString());}


public UpdateUserProfileResult updateUserProfile(UpdateUserProfileRequest request) {request = beforeClientExecution(request);return executeUpdateUserProfile(request);}

public virtual UpdateUserProfileResponse UpdateUserProfile(UpdateUserProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserProfileResponseUnmarshaller.Instance;return Invoke<UpdateUserProfileResponse>(request, options);}

[User] public UpdateUserProfileResult updateUserProfile(UpdateUserProfileRequest request) {request = beforeClientExecution(request);return executeUpdateUserProfile(request);}

[Assistant] public virtual UpdateUserProfileResponse UpdateUserProfile(UpdateUserProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateUserProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateUserProfileResponseUnmarshaller.Instance;return Invoke<UpdateUserProfileResponse>(request, options);}


public RevFilter clone() {final RevFilter[] s = new RevFilter[subfilters.length];for (int i = 0; i < s.length; i++)s[i] = subfilters[i].clone();return new List(s);}

public override TreeFilter Clone(){TreeFilter[] s = new TreeFilter[subfilters.Length];for (int i = 0; i < s.Length; i++){s[i] = subfilters[i].Clone();}return new AndTreeFilter.List(s);}

[User] public RevFilter clone() {final RevFilter[] s = new RevFilter[subfilters.length];for (int i = 0; i < s.length; i++)s[i] = subfilters[i].clone();return new List(s);}

[Assistant] public override TreeFilter Clone(){TreeFilter[] s = new TreeFilter[subfilters.Length];for (int i = 0; i < s.Length; i++){s[i] = subfilters[i].Clone();}return new AndTreeFilter.List(s);}


public GetFederationTokenRequest(String name) {setName(name);}

public GetFederationTokenRequest(string name){_name = name;}

[User] public GetFederationTokenRequest(String name) {setName(name);}

[Assistant] public GetFederationTokenRequest(string name){_name = name;}


public static Cell translateUnicodeValues(Cell cell) {String s = cell.getRichStringCellValue().getString();boolean foundUnicode = false;String lowerCaseStr = s.toLowerCase(Locale.ROOT);for (UnicodeMapping entry : unicodeMappings) {String key = entry.entityName;if (lowerCaseStr.contains(key)) {s = s.replaceAll(key, entry.resolvedValue);foundUnicode = true;}}if (foundUnicode) {cell.setCellValue(cell.getRow().getSheet().getWorkbook().getCreationHelper().createRichTextString(s));}return cell;}

public static ICell TranslateUnicodeValues(ICell cell){String s = cell.RichStringCellValue.String;bool foundUnicode = false;String lowerCaseStr = s.ToLower();for (int i = 0; i < unicodeMappings.Length; i++){UnicodeMapping entry = unicodeMappings[i];String key = entry.entityName;if (lowerCaseStr.IndexOf(key, StringComparison.Ordinal) != -1){s = s.Replace(key, entry.resolvedValue);foundUnicode = true;}}if (foundUnicode){cell.SetCellValue(new HSSFRichTextString(s));}return cell;}

[User] public static Cell translateUnicodeValues(Cell cell) {String s = cell.getRichStringCellValue().getString();boolean foundUnicode = false;String lowerCaseStr = s.toLowerCase(Locale.ROOT);for (UnicodeMapping entry : unicodeMappings) {String key = entry.entityName;if (lowerCaseStr.contains(key)) {s = s.replaceAll(key, entry.resolvedValue);foundUnicode = true;}}if (foundUnicode) {cell.setCellValue(cell.getRow().getSheet().getWorkbook().getCreationHelper().createRichTextString(s));}return cell;}

[Assistant] public static ICell TranslateUnicodeValues(ICell cell){String s = cell.RichStringCellValue.String;bool foundUnicode = false;String lowerCaseStr = s.ToLower();for (int i = 0; i < unicodeMappings.Length; i++){UnicodeMapping entry = unicodeMappings[i];String key = entry.entityName;if (lowerCaseStr.IndexOf(key, StringComparison.Ordinal) != -1){s = s.Replace(key, entry.resolvedValue);foundUnicode = true;}}if (foundUnicode){cell.SetCellValue(new HSSFRichTextString(s));}return cell;}


public CreateChangeSetResult createChangeSet(CreateChangeSetRequest request) {request = beforeClientExecution(request);return executeCreateChangeSet(request);}

public virtual CreateChangeSetResponse CreateChangeSet(CreateChangeSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateChangeSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateChangeSetResponseUnmarshaller.Instance;return Invoke<CreateChangeSetResponse>(request, options);}

[User] public CreateChangeSetResult createChangeSet(CreateChangeSetRequest request) {request = beforeClientExecution(request);return executeCreateChangeSet(request);}

[Assistant] public virtual CreateChangeSetResponse CreateChangeSet(CreateChangeSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateChangeSetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateChangeSetResponseUnmarshaller.Instance;return Invoke<CreateChangeSetResponse>(request, options);}


public SubmoduleStatusCommand(Repository repo) {super(repo);paths = new ArrayList<>();}

protected internal SubmoduleStatusCommand(Repository repo) : base(repo){paths = new AList<string>();}

[User] public SubmoduleStatusCommand(Repository repo) {super(repo);paths = new ArrayList<>();}

[Assistant] protected internal SubmoduleStatusCommand(Repository repo) : base(repo){paths = new AList<string>();}


public int getResultStart() {return outRegion.resultStart;}

public virtual int GetResultStart(){return currentSource.regionList.resultStart;}

[User] public int getResultStart() {return outRegion.resultStart;}

[Assistant] public virtual int GetResultStart(){return currentSource.regionList.resultStart;}


public static BigInteger round(BigInteger bi, int nBits) {if (nBits < 1) {return bi;}return bi.add(HALF_BITS[nBits]);}

public static BigInteger Round(BigInteger bi, int nBits){if (nBits < 1){return bi;}return bi+(HALF_BITS[nBits]);}

[User] public static BigInteger round(BigInteger bi, int nBits) {if (nBits < 1) {return bi;}return bi.add(HALF_BITS[nBits]);}

[Assistant] public static BigInteger Round(BigInteger bi, int nBits){if (nBits < 1){return bi;}return bi+(HALF_BITS[nBits]);}


public static Date round(Date date, Resolution resolution) {return new Date(round(date.getTime(), resolution));}

public static DateTime Round(DateTime date, Resolution resolution){return new DateTime(Round(date.Ticks / TimeSpan.TicksPerMillisecond, resolution));}

[User] public static Date round(Date date, Resolution resolution) {return new Date(round(date.getTime(), resolution));}

[Assistant] public static DateTime Round(DateTime date, Resolution resolution){return new DateTime(Round(date.Ticks / TimeSpan.TicksPerMillisecond, resolution));}


public static int compareArrayByPrefix(char[] shortArray, int shortIndex,char[] longArray, int longIndex) {if (shortArray == null)return 0;else if (longArray == null)return (shortIndex < shortArray.length) ? 1 : 0;int si = shortIndex, li = longIndex;while (si < shortArray.length && li < longArray.length&& shortArray[si] == longArray[li]) {si++;li++;}if (si == shortArray.length) {return 0;} else {if (li == longArray.length)return 1;elsereturn (shortArray[si] > longArray[li]) ? 1 : -1;}}

public static int CompareArrayByPrefix(char[] shortArray, int shortIndex,char[] longArray, int longIndex){if (shortArray == null)return 0;else if (longArray == null)return (shortIndex < shortArray.Length) ? 1 : 0;int si = shortIndex, li = longIndex;while (si < shortArray.Length && li < longArray.Length&& shortArray[si] == longArray[li]){si++;li++;}if (si == shortArray.Length){return 0;}else{if (li == longArray.Length)return 1;elsereturn (shortArray[si] > longArray[li]) ? 1 : -1;}}

[User] public static int compareArrayByPrefix(char[] shortArray, int shortIndex,char[] longArray, int longIndex) {if (shortArray == null)return 0;else if (longArray == null)return (shortIndex < shortArray.length) ? 1 : 0;int si = shortIndex, li = longIndex;while (si < shortArray.length && li < longArray.length&& shortArray[si] == longArray[li]) {si++;li++;}if (si == shortArray.length) {return 0;} else {if (li == longArray.length)return 1;elsereturn (shortArray[si] > longArray[li]) ? 1 : -1;}}

[Assistant] public static int CompareArrayByPrefix(char[] shortArray, int shortIndex,char[] longArray, int longIndex){if (shortArray == null)return 0;else if (longArray == null)return (shortIndex < shortArray.Length) ? 1 : 0;int si = shortIndex, li = longIndex;while (si < shortArray.Length && li < longArray.Length&& shortArray[si] == longArray[li]){si++;li++;}if (si == shortArray.Length){return 0;}else{if (li == longArray.Length)return 1;elsereturn (shortArray[si] > longArray[li]) ? 1 : -1;}}


public AttachInternetGatewayResult attachInternetGateway(AttachInternetGatewayRequest request) {request = beforeClientExecution(request);return executeAttachInternetGateway(request);}

public virtual AttachInternetGatewayResponse AttachInternetGateway(AttachInternetGatewayRequest request){var options = new InvokeOptions();options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance;options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance;return Invoke<AttachInternetGatewayResponse>(request, options);}

[User] public AttachInternetGatewayResult attachInternetGateway(AttachInternetGatewayRequest request) {request = beforeClientExecution(request);return executeAttachInternetGateway(request);}

[Assistant] public virtual AttachInternetGatewayResponse AttachInternetGateway(AttachInternetGatewayRequest request){var options = new InvokeOptions();options.RequestMarshaller = AttachInternetGatewayRequestMarshaller.Instance;options.ResponseUnmarshaller = AttachInternetGatewayResponseUnmarshaller.Instance;return Invoke<AttachInternetGatewayResponse>(request, options);}


public synchronized boolean containsValue(Object value) {if (value == null) {throw new NullPointerException();}HashtableEntry[] tab = table;int len = tab.length;for (int i = 0; i < len; i++) {for (HashtableEntry e = tab[i]; e != null; e = e.next) {if (value.equals(e.value)) {return true;}}}return false;}

public virtual bool containsValue(object value){lock (this){if (value == null){throw new System.ArgumentNullException();}java.util.Hashtable.HashtableEntry<K, V>[] tab = table;int len = tab.Length;{for (int i = 0; i < len; i++){{for (java.util.Hashtable.HashtableEntry<K, V> e = tab[i]; e != null; e = e.next){if (value.Equals(e.value)){return true;}}}}}return false;}}

[User] public synchronized boolean containsValue(Object value) {if (value == null) {throw new NullPointerException();}HashtableEntry[] tab = table;int len = tab.length;for (int i = 0; i < len; i++) {for (HashtableEntry e = tab[i]; e != null; e = e.next) {if (value.equals(e.value)) {return true;}}}return false;}

[Assistant] public virtual bool containsValue(object value){lock (this){if (value == null){throw new System.ArgumentNullException();}java.util.Hashtable.HashtableEntry<K, V>[] tab = table;int len = tab.Length;{for (int i = 0; i < len; i++){{for (java.util.Hashtable.HashtableEntry<K, V> e = tab[i]; e != null; e = e.next){if (value.Equals(e.value)){return true;}}}}}return false;}}


public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append( operands[0] );buffer.append("<=");buffer.append( operands[1] );return buffer.toString();}

public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append("<=");buffer.Append(operands[1]);return buffer.ToString();}

[User] public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append( operands[0] );buffer.append("<=");buffer.append( operands[1] );return buffer.toString();}

[Assistant] public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append("<=");buffer.Append(operands[1]);return buffer.ToString();}


public void write(String str) {write(str.toCharArray());}

public override void write(string str){write(str.ToCharArray());}

[User] public void write(String str) {write(str.toCharArray());}

[Assistant] public override void write(string str){write(str.ToCharArray());}


public Sort(SortField... fields) {setSort(fields);}

[User] public Sort(SortField... fields) {setSort(fields);}

[Assistant] public Sort(SortField field){SetSort(field);}


public DescribeEventCategoriesResult describeEventCategories(DescribeEventCategoriesRequest request) {request = beforeClientExecution(request);return executeDescribeEventCategories(request);}

public virtual DescribeEventCategoriesResponse DescribeEventCategories(DescribeEventCategoriesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance;return Invoke<DescribeEventCategoriesResponse>(request, options);}

[User] public DescribeEventCategoriesResult describeEventCategories(DescribeEventCategoriesRequest request) {request = beforeClientExecution(request);return executeDescribeEventCategories(request);}

[Assistant] public virtual DescribeEventCategoriesResponse DescribeEventCategories(DescribeEventCategoriesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEventCategoriesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEventCategoriesResponseUnmarshaller.Instance;return Invoke<DescribeEventCategoriesResponse>(request, options);}


public UpdateDeviceResult updateDevice(UpdateDeviceRequest request) {request = beforeClientExecution(request);return executeUpdateDevice(request);}

public virtual UpdateDeviceResponse UpdateDevice(UpdateDeviceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDeviceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDeviceResponseUnmarshaller.Instance;return Invoke<UpdateDeviceResponse>(request, options);}

[User] public UpdateDeviceResult updateDevice(UpdateDeviceRequest request) {request = beforeClientExecution(request);return executeUpdateDevice(request);}

[Assistant] public virtual UpdateDeviceResponse UpdateDevice(UpdateDeviceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDeviceRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDeviceResponseUnmarshaller.Instance;return Invoke<UpdateDeviceResponse>(request, options);}


public CreateWorkerBlockResult createWorkerBlock(CreateWorkerBlockRequest request) {request = beforeClientExecution(request);return executeCreateWorkerBlock(request);}

public virtual CreateWorkerBlockResponse CreateWorkerBlock(CreateWorkerBlockRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateWorkerBlockRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateWorkerBlockResponseUnmarshaller.Instance;return Invoke<CreateWorkerBlockResponse>(request, options);}

[User] public CreateWorkerBlockResult createWorkerBlock(CreateWorkerBlockRequest request) {request = beforeClientExecution(request);return executeCreateWorkerBlock(request);}

[Assistant] public virtual CreateWorkerBlockResponse CreateWorkerBlock(CreateWorkerBlockRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateWorkerBlockRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateWorkerBlockResponseUnmarshaller.Instance;return Invoke<CreateWorkerBlockResponse>(request, options);}


public synchronized void reset() throws IOException {throw new IOException();}

public virtual void reset(){lock (this){throw new System.IO.IOException();}}

[User] public synchronized void reset() throws IOException {throw new IOException();}

[Assistant] public virtual void reset(){lock (this){throw new System.IO.IOException();}}


public final void setReader(Reader input) {if (input == null) {throw new NullPointerException("input must not be null");} else if (this.input != ILLEGAL_STATE_READER) {throw new IllegalStateException("TokenStream contract violation: close() call missing");}this.inputPending = input;setReaderTestPoint();}

public void SetReader(TextReader input){if (input == null){throw new System.ArgumentNullException("value", "input must not be null");}else if (this.m_input != ILLEGAL_STATE_READER){throw new InvalidOperationException("TokenStream contract violation: Close() call missing");}this.inputPending = input;Debug.Assert(SetReaderTestPoint());}

[User] public final void setReader(Reader input) {if (input == null) {throw new NullPointerException("input must not be null");} else if (this.input != ILLEGAL_STATE_READER) {throw new IllegalStateException("TokenStream contract violation: close() call missing");}this.inputPending = input;setReaderTestPoint();}

[Assistant] public void SetReader(TextReader input){if (input == null){throw new System.ArgumentNullException("value", "input must not be null");}else if (this.m_input != ILLEGAL_STATE_READER){throw new InvalidOperationException("TokenStream contract violation: Close() call missing");}this.inputPending = input;Debug.Assert(SetReaderTestPoint());}


public GetUsagePlanKeysResult getUsagePlanKeys(GetUsagePlanKeysRequest request) {request = beforeClientExecution(request);return executeGetUsagePlanKeys(request);}

public virtual GetUsagePlanKeysResponse GetUsagePlanKeys(GetUsagePlanKeysRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetUsagePlanKeysRequestMarshaller.Instance;options.ResponseUnmarshaller = GetUsagePlanKeysResponseUnmarshaller.Instance;return Invoke<GetUsagePlanKeysResponse>(request, options);}

[User] public GetUsagePlanKeysResult getUsagePlanKeys(GetUsagePlanKeysRequest request) {request = beforeClientExecution(request);return executeGetUsagePlanKeys(request);}

[Assistant] public virtual GetUsagePlanKeysResponse GetUsagePlanKeys(GetUsagePlanKeysRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetUsagePlanKeysRequestMarshaller.Instance;options.ResponseUnmarshaller = GetUsagePlanKeysResponseUnmarshaller.Instance;return Invoke<GetUsagePlanKeysResponse>(request, options);}


public String toString(){StringBuilder sb = new StringBuilder();sb.append( "subInfos=(" );for( SubInfo si : subInfos )sb.append( si.toString() );sb.append( ")/" ).append( totalBoost ).append( '(' ).append( startOffset ).append( ',' ).append( endOffset ).append( ')' );return sb.toString();}

public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append("subInfos=(");foreach (SubInfo si in subInfos)sb.Append(si.ToString());sb.Append(")/").Append(Number.ToString(totalBoost)).Append('(').Append(startOffset).Append(',').Append(endOffset).Append(')');return sb.ToString();}

[User] public String toString(){StringBuilder sb = new StringBuilder();sb.append( "subInfos=(" );for( SubInfo si : subInfos )sb.append( si.toString() );sb.append( ")/" ).append( totalBoost ).append( '(' ).append( startOffset ).append( ',' ).append( endOffset ).append( ')' );return sb.toString();}

[Assistant] public override string ToString(){StringBuilder sb = new StringBuilder();sb.Append("subInfos=(");foreach (SubInfo si in subInfos)sb.Append(si.ToString());sb.Append(")/").Append(Number.ToString(totalBoost)).Append('(').Append(startOffset).Append(',').Append(endOffset).Append(')');return sb.ToString();}


public TokenStream create(TokenStream input) {return new LimitTokenPositionFilter(input, maxTokenPosition, consumeAllTokens);}

public override TokenStream Create(TokenStream input){return new LimitTokenPositionFilter(input, maxTokenPosition, consumeAllTokens);}

[User] public TokenStream create(TokenStream input) {return new LimitTokenPositionFilter(input, maxTokenPosition, consumeAllTokens);}

[Assistant] public override TokenStream Create(TokenStream input){return new LimitTokenPositionFilter(input, maxTokenPosition, consumeAllTokens);}


public DescribeFleetUtilizationResult describeFleetUtilization(DescribeFleetUtilizationRequest request) {request = beforeClientExecution(request);return executeDescribeFleetUtilization(request);}

public virtual DescribeFleetUtilizationResponse DescribeFleetUtilization(DescribeFleetUtilizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetUtilizationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetUtilizationResponseUnmarshaller.Instance;return Invoke<DescribeFleetUtilizationResponse>(request, options);}

[User] public DescribeFleetUtilizationResult describeFleetUtilization(DescribeFleetUtilizationRequest request) {request = beforeClientExecution(request);return executeDescribeFleetUtilization(request);}

[Assistant] public virtual DescribeFleetUtilizationResponse DescribeFleetUtilization(DescribeFleetUtilizationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFleetUtilizationRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFleetUtilizationResponseUnmarshaller.Instance;return Invoke<DescribeFleetUtilizationResponse>(request, options);}


public void inform(ResourceLoader loader) throws IOException {InputStream stream = null;try {if (dictFile != null) dictionary = getWordSet(loader, dictFile, false);stream = loader.openResource(hypFile);final InputSource is = new InputSource(stream);is.setEncoding(encoding); is.setSystemId(hypFile);hyphenator = HyphenationCompoundWordTokenFilter.getHyphenationTree(is);} finally {IOUtils.closeWhileHandlingException(stream);}}

public virtual void Inform(IResourceLoader loader){Stream stream = null;try{if (dictFile != null) {dictionary = GetWordSet(loader, dictFile, false);}stream = loader.OpenResource(hypFile);var xmlEncoding = string.IsNullOrEmpty(encoding) ? Encoding.UTF8 : Encoding.GetEncoding(encoding);hyphenator = HyphenationCompoundWordTokenFilter.GetHyphenationTree(stream, xmlEncoding);}finally{IOUtils.DisposeWhileHandlingException(stream);}}

[User] public void inform(ResourceLoader loader) throws IOException {InputStream stream = null;try {if (dictFile != null) dictionary = getWordSet(loader, dictFile, false);stream = loader.openResource(hypFile);final InputSource is = new InputSource(stream);is.setEncoding(encoding); is.setSystemId(hypFile);hyphenator = HyphenationCompoundWordTokenFilter.getHyphenationTree(is);} finally {IOUtils.closeWhileHandlingException(stream);}}

[Assistant] public virtual void Inform(IResourceLoader loader){Stream stream = null;try{if (dictFile != null) {dictionary = GetWordSet(loader, dictFile, false);}stream = loader.OpenResource(hypFile);var xmlEncoding = string.IsNullOrEmpty(encoding) ? Encoding.UTF8 : Encoding.GetEncoding(encoding);hyphenator = HyphenationCompoundWordTokenFilter.GetHyphenationTree(stream, xmlEncoding);}finally{IOUtils.DisposeWhileHandlingException(stream);}}


public DeclineInvitationsResult declineInvitations(DeclineInvitationsRequest request) {request = beforeClientExecution(request);return executeDeclineInvitations(request);}

public virtual DeclineInvitationsResponse DeclineInvitations(DeclineInvitationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeclineInvitationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeclineInvitationsResponseUnmarshaller.Instance;return Invoke<DeclineInvitationsResponse>(request, options);}

[User] public DeclineInvitationsResult declineInvitations(DeclineInvitationsRequest request) {request = beforeClientExecution(request);return executeDeclineInvitations(request);}

[Assistant] public virtual DeclineInvitationsResponse DeclineInvitations(DeclineInvitationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeclineInvitationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeclineInvitationsResponseUnmarshaller.Instance;return Invoke<DeclineInvitationsResponse>(request, options);}


public DescribeAutoScalingGroupsResult describeAutoScalingGroups() {return describeAutoScalingGroups(new DescribeAutoScalingGroupsRequest());}

public virtual DescribeAutoScalingGroupsResponse DescribeAutoScalingGroups(){return DescribeAutoScalingGroups(new DescribeAutoScalingGroupsRequest());}

[User] public DescribeAutoScalingGroupsResult describeAutoScalingGroups() {return describeAutoScalingGroups(new DescribeAutoScalingGroupsRequest());}

[Assistant] public virtual DescribeAutoScalingGroupsResponse DescribeAutoScalingGroups(){return DescribeAutoScalingGroups(new DescribeAutoScalingGroupsRequest());}


public String toString() {return String.format("pushMode(%d)", mode);}

public override string ToString(){return string.Format("pushMode({0})", mode);}

[User] public String toString() {return String.format("pushMode(%d)", mode);}

[Assistant] public override string ToString(){return string.Format("pushMode({0})", mode);}


public CreateBranchCommand setStartPoint(String startPoint) {checkCallable();this.startPoint = startPoint;this.startCommit = null;return this;}

public virtual NGit.Api.CreateBranchCommand SetStartPoint(string startPoint){CheckCallable();this.startPoint = startPoint;this.startCommit = null;return this;}

[User] public CreateBranchCommand setStartPoint(String startPoint) {checkCallable();this.startPoint = startPoint;this.startCommit = null;return this;}

[Assistant] public virtual NGit.Api.CreateBranchCommand SetStartPoint(string startPoint){CheckCallable();this.startPoint = startPoint;this.startCommit = null;return this;}


public DBInstance stopDBInstance(StopDBInstanceRequest request) {request = beforeClientExecution(request);return executeStopDBInstance(request);}

public virtual StopDBInstanceResponse StopDBInstance(StopDBInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopDBInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StopDBInstanceResponseUnmarshaller.Instance;return Invoke<StopDBInstanceResponse>(request, options);}

[User] public DBInstance stopDBInstance(StopDBInstanceRequest request) {request = beforeClientExecution(request);return executeStopDBInstance(request);}

[Assistant] public virtual StopDBInstanceResponse StopDBInstance(StopDBInstanceRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopDBInstanceRequestMarshaller.Instance;options.ResponseUnmarshaller = StopDBInstanceResponseUnmarshaller.Instance;return Invoke<StopDBInstanceResponse>(request, options);}


public SuggestWordQueue(int size, Comparator<SuggestWord> comparator){super(size);this.comparator = comparator;}

public SuggestWordQueue(int size, IComparer<SuggestWord> comparer): base(size){this.comparer = comparer;}

[User] public SuggestWordQueue(int size, Comparator<SuggestWord> comparator){super(size);this.comparator = comparator;}

[Assistant] public SuggestWordQueue(int size, IComparer<SuggestWord> comparer): base(size){this.comparer = comparer;}


public LBCookieStickinessPolicy(String policyName, Long cookieExpirationPeriod) {setPolicyName(policyName);setCookieExpirationPeriod(cookieExpirationPeriod);}

public LBCookieStickinessPolicy(string policyName, long cookieExpirationPeriod){_policyName = policyName;_cookieExpirationPeriod = cookieExpirationPeriod;}

[User] public LBCookieStickinessPolicy(String policyName, Long cookieExpirationPeriod) {setPolicyName(policyName);setCookieExpirationPeriod(cookieExpirationPeriod);}

[Assistant] public LBCookieStickinessPolicy(string policyName, long cookieExpirationPeriod){_policyName = policyName;_cookieExpirationPeriod = cookieExpirationPeriod;}


public SheetRangeEvaluator(int firstSheetIndex, int lastSheetIndex, SheetRefEvaluator[] sheetEvaluators) {if (firstSheetIndex < 0) {throw new IllegalArgumentException("Invalid firstSheetIndex: " + firstSheetIndex + ".");}if (lastSheetIndex < firstSheetIndex) {throw new IllegalArgumentException("Invalid lastSheetIndex: " + lastSheetIndex + " for firstSheetIndex: " + firstSheetIndex + ".");}_firstSheetIndex = firstSheetIndex;_lastSheetIndex = lastSheetIndex;_sheetEvaluators = sheetEvaluators.clone();}

public SheetRangeEvaluator(int firstSheetIndex, int lastSheetIndex, SheetRefEvaluator[] sheetEvaluators){if (firstSheetIndex < 0){throw new ArgumentException("Invalid firstSheetIndex: " + firstSheetIndex + ".");}if (lastSheetIndex < firstSheetIndex){throw new ArgumentException("Invalid lastSheetIndex: " + lastSheetIndex + " for firstSheetIndex: " + firstSheetIndex + ".");}_firstSheetIndex = firstSheetIndex;_lastSheetIndex = lastSheetIndex;_sheetEvaluators = sheetEvaluators;}

[User] public SheetRangeEvaluator(int firstSheetIndex, int lastSheetIndex, SheetRefEvaluator[] sheetEvaluators) {if (firstSheetIndex < 0) {throw new IllegalArgumentException("Invalid firstSheetIndex: " + firstSheetIndex + ".");}if (lastSheetIndex < firstSheetIndex) {throw new IllegalArgumentException("Invalid lastSheetIndex: " + lastSheetIndex + " for firstSheetIndex: " + firstSheetIndex + ".");}_firstSheetIndex = firstSheetIndex;_lastSheetIndex = lastSheetIndex;_sheetEvaluators = sheetEvaluators.clone();}

[Assistant] public SheetRangeEvaluator(int firstSheetIndex, int lastSheetIndex, SheetRefEvaluator[] sheetEvaluators){if (firstSheetIndex < 0){throw new ArgumentException("Invalid firstSheetIndex: " + firstSheetIndex + ".");}if (lastSheetIndex < firstSheetIndex){throw new ArgumentException("Invalid lastSheetIndex: " + lastSheetIndex + " for firstSheetIndex: " + firstSheetIndex + ".");}_firstSheetIndex = firstSheetIndex;_lastSheetIndex = lastSheetIndex;_sheetEvaluators = sheetEvaluators;}


public RevokeTokenRequest() {super("OnsMqtt", "2019-12-11", "RevokeToken", "onsmqtt");setMethod(MethodType.POST);}

public RevokeTokenRequest(): base("OnsMqtt", "2019-12-11", "RevokeToken", "onsmqtt", "openAPI"){Method = MethodType.POST;}

[User] public RevokeTokenRequest() {super("OnsMqtt", "2019-12-11", "RevokeToken", "onsmqtt");setMethod(MethodType.POST);}

[Assistant] public RevokeTokenRequest(): base("OnsMqtt", "2019-12-11", "RevokeToken", "onsmqtt", "openAPI"){Method = MethodType.POST;}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) {try {ValueEval ve = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);double result = OperandResolver.coerceValueToDouble(ve);if (Double.isNaN(result) || Double.isInfinite(result)) {throw new EvaluationException(ErrorEval.NUM_ERROR);}if (arg1 instanceof RefListEval) {return eval(result, ((RefListEval)arg1), true);}final AreaEval aeRange = convertRangeArg(arg1);return eval(result, aeRange, true);} catch (EvaluationException e) {return e.getErrorEval();}}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1){AreaEval aeRange;double result;try{ValueEval ve = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);result = OperandResolver.CoerceValueToDouble(ve);if (Double.IsNaN(result) || Double.IsInfinity(result)){throw new EvaluationException(ErrorEval.NUM_ERROR);}aeRange = ConvertRangeArg(arg1);}catch (EvaluationException e){return e.GetErrorEval();}return eval(srcRowIndex, srcColumnIndex, result, aeRange, true);}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1) {try {ValueEval ve = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);double result = OperandResolver.coerceValueToDouble(ve);if (Double.isNaN(result) || Double.isInfinite(result)) {throw new EvaluationException(ErrorEval.NUM_ERROR);}if (arg1 instanceof RefListEval) {return eval(result, ((RefListEval)arg1), true);}final AreaEval aeRange = convertRangeArg(arg1);return eval(result, aeRange, true);} catch (EvaluationException e) {return e.getErrorEval();}}

[Assistant] public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1){AreaEval aeRange;double result;try{ValueEval ve = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);result = OperandResolver.CoerceValueToDouble(ve);if (Double.IsNaN(result) || Double.IsInfinity(result)){throw new EvaluationException(ErrorEval.NUM_ERROR);}aeRange = ConvertRangeArg(arg1);}catch (EvaluationException e){return e.GetErrorEval();}return eval(srcRowIndex, srcColumnIndex, result, aeRange, true);}


public String toFormulaString() {return "";}

public override String ToFormulaString(){return "";}

[User] public String toFormulaString() {return "";}

[Assistant] public override String ToFormulaString(){return "";}


public byte readByte() throws IOException {if (bufferPos == bufferSize) {refill();}assert bufferPos == buffer.position() : "bufferPos=" + bufferPos + " vs buffer.position()=" + buffer.position();bufferPos++;return buffer.get();}

public sbyte readByte() throws IOException{if (bufferPos == bufferSize){refill();}Debug.Assert(bufferPos == buffer.position(), "bufferPos=" + bufferPos + " vs buffer.position()=" + buffer.position());bufferPos++;return buffer.get();}

[User] public byte readByte() throws IOException {if (bufferPos == bufferSize) {refill();}assert bufferPos == buffer.position() : "bufferPos=" + bufferPos + " vs buffer.position()=" + buffer.position();bufferPos++;return buffer.get();}

[Assistant] public sbyte readByte() throws IOException{if (bufferPos == bufferSize){refill();}Debug.Assert(bufferPos == buffer.position(), "bufferPos=" + bufferPos + " vs buffer.position()=" + buffer.position());bufferPos++;return buffer.get();}


public ListTargetsByRuleResult listTargetsByRule(ListTargetsByRuleRequest request) {request = beforeClientExecution(request);return executeListTargetsByRule(request);}

public virtual ListTargetsByRuleResponse ListTargetsByRule(ListTargetsByRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTargetsByRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTargetsByRuleResponseUnmarshaller.Instance;return Invoke<ListTargetsByRuleResponse>(request, options);}

[User] public ListTargetsByRuleResult listTargetsByRule(ListTargetsByRuleRequest request) {request = beforeClientExecution(request);return executeListTargetsByRule(request);}

[Assistant] public virtual ListTargetsByRuleResponse ListTargetsByRule(ListTargetsByRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTargetsByRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTargetsByRuleResponseUnmarshaller.Instance;return Invoke<ListTargetsByRuleResponse>(request, options);}


public DisassociateQualificationFromWorkerResult disassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request) {request = beforeClientExecution(request);return executeDisassociateQualificationFromWorker(request);}

public virtual DisassociateQualificationFromWorkerResponse DisassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateQualificationFromWorkerRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateQualificationFromWorkerResponseUnmarshaller.Instance;return Invoke<DisassociateQualificationFromWorkerResponse>(request, options);}

[User] public DisassociateQualificationFromWorkerResult disassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request) {request = beforeClientExecution(request);return executeDisassociateQualificationFromWorker(request);}

[Assistant] public virtual DisassociateQualificationFromWorkerResponse DisassociateQualificationFromWorker(DisassociateQualificationFromWorkerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateQualificationFromWorkerRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateQualificationFromWorkerResponseUnmarshaller.Instance;return Invoke<DisassociateQualificationFromWorkerResponse>(request, options);}


public boolean equals(Object obj) {if (this == obj) return true;if (obj == null) return false;if (getClass() != obj.getClass()) return false;CompiledAutomaton other = (CompiledAutomaton) obj;if (type != other.type) return false;if (type == AUTOMATON_TYPE.SINGLE) {if (!term.equals(other.term)) return false;} else if (type == AUTOMATON_TYPE.NORMAL) {if (!runAutomaton.equals(other.runAutomaton)) return false;}return true;}

public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (this.GetType() != obj.GetType()){return false;}CompiledAutomaton other = (CompiledAutomaton)obj;if (Type != other.Type){return false;}if (Type == AUTOMATON_TYPE.SINGLE || Type == AUTOMATON_TYPE.PREFIX){if (!Term.Equals(other.Term)){return false;}}else if (Type == AUTOMATON_TYPE.NORMAL){if (!RunAutomaton.Equals(other.RunAutomaton)){return false;}}return true;}

[User] public boolean equals(Object obj) {if (this == obj) return true;if (obj == null) return false;if (getClass() != obj.getClass()) return false;CompiledAutomaton other = (CompiledAutomaton) obj;if (type != other.type) return false;if (type == AUTOMATON_TYPE.SINGLE) {if (!term.equals(other.term)) return false;} else if (type == AUTOMATON_TYPE.NORMAL) {if (!runAutomaton.equals(other.runAutomaton)) return false;}return true;}

[Assistant] public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (this.GetType() != obj.GetType()){return false;}CompiledAutomaton other = (CompiledAutomaton)obj;if (Type != other.Type){return false;}if (Type == AUTOMATON_TYPE.SINGLE || Type == AUTOMATON_TYPE.PREFIX){if (!Term.Equals(other.Term)){return false;}}else if (Type == AUTOMATON_TYPE.NORMAL){if (!RunAutomaton.Equals(other.RunAutomaton)){return false;}}return true;}


public static CharFilterFactory forName(String name, Map<String,String> args) {return loader.newInstance(name, args);}

public static CharFilterFactory ForName(string name, IDictionary<string, string> args){return loader.NewInstance(name, args);}

[User] public static CharFilterFactory forName(String name, Map<String,String> args) {return loader.newInstance(name, args);}

[Assistant] public static CharFilterFactory ForName(string name, IDictionary<string, string> args){return loader.NewInstance(name, args);}


public String toString() {String[] units = { "bytes", "KiB", "MiB", "GiB" };long sz = getIndexSize();int u = 0;while (1024 <= sz && u < units.length - 1) {int rem = (int) (sz % 1024);sz /= 1024;if (rem != 0)sz++;u++;}return "DeltaIndex[" + sz + " " + units[u] + "]";}

public override string ToString(){string[] units = new string[] { "bytes", "KiB", "MiB", "GiB" };long sz = GetIndexSize();int u = 0;while (1024 <= sz && u < units.Length - 1){int rem = (int)(sz % 1024);sz /= 1024;if (rem != 0){sz++;}u++;}return "DeltaIndex[" + sz + " " + units[u] + "]";}

[User] public String toString() {String[] units = { "bytes", "KiB", "MiB", "GiB" };long sz = getIndexSize();int u = 0;while (1024 <= sz && u < units.length - 1) {int rem = (int) (sz % 1024);sz /= 1024;if (rem != 0)sz++;u++;}return "DeltaIndex[" + sz + " " + units[u] + "]";}

[Assistant] public override string ToString(){string[] units = new string[] { "bytes", "KiB", "MiB", "GiB" };long sz = GetIndexSize();int u = 0;while (1024 <= sz && u < units.Length - 1){int rem = (int)(sz % 1024);sz /= 1024;if (rem != 0){sz++;}u++;}return "DeltaIndex[" + sz + " " + units[u] + "]";}


public SimilarityConfig build() {return new SimilarityConfig(this);}

public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}

[User] public SimilarityConfig build() {return new SimilarityConfig(this);}

[Assistant] public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}


public void mark(int readLimit) throws IOException {throw new IOException();}

public virtual void mark(int readLimit){throw new System.IO.IOException();}

[User] public void mark(int readLimit) throws IOException {throw new IOException();}

[Assistant] public virtual void mark(int readLimit){throw new System.IO.IOException();}


public void collect(int doc) throws IOException {final long time = clock.get();if (time - timeout > 0L) {if (greedy) {in.collect(doc);}throw new TimeExceededException( timeout-t0, time-t0, docBase + doc );}in.collect(doc);}

public virtual void Collect(int doc){long time = clock.Get();if (timeout < time){if (greedy){collector.Collect(doc);}throw new TimeExceededException(timeout - t0, time - t0, docBase + doc);}collector.Collect(doc);}

[User] public void collect(int doc) throws IOException {final long time = clock.get();if (time - timeout > 0L) {if (greedy) {in.collect(doc);}throw new TimeExceededException( timeout-t0, time-t0, docBase + doc );}in.collect(doc);}

[Assistant] public virtual void Collect(int doc){long time = clock.Get();if (timeout < time){if (greedy){collector.Collect(doc);}throw new TimeExceededException(timeout - t0, time - t0, docBase + doc);}collector.Collect(doc);}


public LocalFile(File directory, int inCoreLimit) {super(inCoreLimit);this.directory = directory;}

public LocalFile(FilePath directory, int inCoreLimit) : base(inCoreLimit){this.directory = directory;}

[User] public LocalFile(File directory, int inCoreLimit) {super(inCoreLimit);this.directory = directory;}

[Assistant] public LocalFile(FilePath directory, int inCoreLimit) : base(inCoreLimit){this.directory = directory;}


@Override public E remove(int index) {Object[] a = array;int s = size;if (index >= s) {throwIndexOutOfBoundsException(index, s);}@SuppressWarnings("unchecked") E result = (E) a[index];System.arraycopy(a, index + 1, a, index, --s - index);a[s] = null;  size = s;modCount++;return result;}

public override E remove(int index){object[] a = array;int s = _size;if (index >= s){throwIndexOutOfBoundsException(index, s);}E result = (E)a[index];System.Array.Copy(a, index + 1, a, index, --s - index);a[s] = null;_size = s;modCount++;return result;}

[User] @Override public E remove(int index) {Object[] a = array;int s = size;if (index >= s) {throwIndexOutOfBoundsException(index, s);}@SuppressWarnings("unchecked") E result = (E) a[index];System.arraycopy(a, index + 1, a, index, --s - index);a[s] = null;  size = s;modCount++;return result;}

[Assistant] public override E remove(int index){object[] a = array;int s = _size;if (index >= s){throwIndexOutOfBoundsException(index, s);}E result = (E)a[index];System.Array.Copy(a, index + 1, a, index, --s - index);a[s] = null;_size = s;modCount++;return result;}


public RequestUploadCredentialsResult requestUploadCredentials(RequestUploadCredentialsRequest request) {request = beforeClientExecution(request);return executeRequestUploadCredentials(request);}

public virtual RequestUploadCredentialsResponse RequestUploadCredentials(RequestUploadCredentialsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RequestUploadCredentialsRequestMarshaller.Instance;options.ResponseUnmarshaller = RequestUploadCredentialsResponseUnmarshaller.Instance;return Invoke<RequestUploadCredentialsResponse>(request, options);}

[User] public RequestUploadCredentialsResult requestUploadCredentials(RequestUploadCredentialsRequest request) {request = beforeClientExecution(request);return executeRequestUploadCredentials(request);}

[Assistant] public virtual RequestUploadCredentialsResponse RequestUploadCredentials(RequestUploadCredentialsRequest request){var options = new InvokeOptions();options.RequestMarshaller = RequestUploadCredentialsRequestMarshaller.Instance;options.ResponseUnmarshaller = RequestUploadCredentialsResponseUnmarshaller.Instance;return Invoke<RequestUploadCredentialsResponse>(request, options);}


public void copyTo(OutputStream out) throws MissingObjectException,IOException {if (isLarge()) {try (ObjectStream in = openStream()) {final long sz = in.getSize();byte[] tmp = new byte[8192];long copied = 0;while (copied < sz) {int n = in.read(tmp);if (n < 0)throw new EOFException();out.write(tmp, 0, n);copied += n;}if (0 <= in.read())throw new EOFException();}} else {out.write(getCachedBytes());}}

public virtual void CopyTo(OutputStream @out){if (IsLarge()){ObjectStream @in = OpenStream();try{long sz = @in.GetSize();byte[] tmp = new byte[8192];long copied = 0;while (copied < sz){int n = @in.Read(tmp);if (n < 0){throw new EOFException();}@out.Write(tmp, 0, n);copied += n;}if (0 <= @in.Read()){throw new EOFException();}}finally{@in.Close();}}else{@out.Write(GetCachedBytes());}}

[User] public void copyTo(OutputStream out) throws MissingObjectException,IOException {if (isLarge()) {try (ObjectStream in = openStream()) {final long sz = in.getSize();byte[] tmp = new byte[8192];long copied = 0;while (copied < sz) {int n = in.read(tmp);if (n < 0)throw new EOFException();out.write(tmp, 0, n);copied += n;}if (0 <= in.read())throw new EOFException();}} else {out.write(getCachedBytes());}}

[Assistant] public virtual void CopyTo(OutputStream @out){if (IsLarge()){ObjectStream @in = OpenStream();try{long sz = @in.GetSize();byte[] tmp = new byte[8192];long copied = 0;while (copied < sz){int n = @in.Read(tmp);if (n < 0){throw new EOFException();}@out.Write(tmp, 0, n);copied += n;}if (0 <= @in.Read()){throw new EOFException();}}finally{@in.Close();}}else{@out.Write(GetCachedBytes());}}


@Override public V remove(Object key) {if (key == null) {return removeNullKey();}int hash = secondaryHash(key.hashCode());HashMapEntry<K, V>[] tab = table;int index = hash & (tab.length - 1);for (HashMapEntry<K, V> e = tab[index], prev = null;e != null; prev = e, e = e.next) {if (e.hash == hash && key.equals(e.key)) {if (prev == null) {tab[index] = e.next;} else {prev.next = e.next;}modCount++;size--;postRemove(e);return e.value;}}return null;}

public override V remove(object key){if (key == null){return removeNullKey();}int hash = secondaryHash(key.GetHashCode());java.util.HashMap.HashMapEntry<K, V>[] tab = table;int index = hash & (tab.Length - 1);{java.util.HashMap.HashMapEntry<K, V> e = tab[index];java.util.HashMap.HashMapEntry<K, V> prev = null;for (; e != null; prev = e, e = e.next){if (e.hash == hash && key.Equals(e.key)){if (prev == null){tab[index] = e.next;}else{prev.next = e.next;}modCount++;_size--;postRemove(e);return e.value;}}}return default(V);}

[User] @Override public V remove(Object key) {if (key == null) {return removeNullKey();}int hash = secondaryHash(key.hashCode());HashMapEntry<K, V>[] tab = table;int index = hash & (tab.length - 1);for (HashMapEntry<K, V> e = tab[index], prev = null;e != null; prev = e, e = e.next) {if (e.hash == hash && key.equals(e.key)) {if (prev == null) {tab[index] = e.next;} else {prev.next = e.next;}modCount++;size--;postRemove(e);return e.value;}}return null;}

[Assistant] public override V remove(object key){if (key == null){return removeNullKey();}int hash = secondaryHash(key.GetHashCode());java.util.HashMap.HashMapEntry<K, V>[] tab = table;int index = hash & (tab.Length - 1);{java.util.HashMap.HashMapEntry<K, V> e = tab[index];java.util.HashMap.HashMapEntry<K, V> prev = null;for (; e != null; prev = e, e = e.next){if (e.hash == hash && key.Equals(e.key)){if (prev == null){tab[index] = e.next;}else{prev.next = e.next;}modCount++;_size--;postRemove(e);return e.value;}}}return default(V);}


public override RevFilter Negate(){return a;}

[User] public RevFilter negate() {return a;}

[Assistant] public override RevFilter Negate(){return a;}


public DescribeVpcsResult describeVpcs(DescribeVpcsRequest request) {request = beforeClientExecution(request);return executeDescribeVpcs(request);}

public virtual DescribeVpcsResponse DescribeVpcs(DescribeVpcsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcsResponseUnmarshaller.Instance;return Invoke<DescribeVpcsResponse>(request, options);}

[User] public DescribeVpcsResult describeVpcs(DescribeVpcsRequest request) {request = beforeClientExecution(request);return executeDescribeVpcs(request);}

[Assistant] public virtual DescribeVpcsResponse DescribeVpcs(DescribeVpcsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcsResponseUnmarshaller.Instance;return Invoke<DescribeVpcsResponse>(request, options);}


public UpdateGameSessionQueueResult updateGameSessionQueue(UpdateGameSessionQueueRequest request) {request = beforeClientExecution(request);return executeUpdateGameSessionQueue(request);}

public virtual UpdateGameSessionQueueResponse UpdateGameSessionQueue(UpdateGameSessionQueueRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGameSessionQueueRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGameSessionQueueResponseUnmarshaller.Instance;return Invoke<UpdateGameSessionQueueResponse>(request, options);}

[User] public UpdateGameSessionQueueResult updateGameSessionQueue(UpdateGameSessionQueueRequest request) {request = beforeClientExecution(request);return executeUpdateGameSessionQueue(request);}

[Assistant] public virtual UpdateGameSessionQueueResponse UpdateGameSessionQueue(UpdateGameSessionQueueRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateGameSessionQueueRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateGameSessionQueueResponseUnmarshaller.Instance;return Invoke<UpdateGameSessionQueueResponse>(request, options);}


public String getTitle() {return title;}

[User] public String getTitle() {return title;}

[Assistant] public String GetTitle(){return title;}


public final void setNewHeads(List<Head> newHeads) {if (this.newHeads != null)throw new IllegalStateException(JGitText.get().propertyIsAlreadyNonNull);this.newHeads = newHeads;}

public void SetNewHeads(IList<Head> newHeads){if (this.newHeads != null){throw new InvalidOperationException(JGitText.Get().propertyIsAlreadyNonNull);}this.newHeads = newHeads;}

[User] public final void setNewHeads(List<Head> newHeads) {if (this.newHeads != null)throw new IllegalStateException(JGitText.get().propertyIsAlreadyNonNull);this.newHeads = newHeads;}

[Assistant] public void SetNewHeads(IList<Head> newHeads){if (this.newHeads != null){throw new InvalidOperationException(JGitText.Get().propertyIsAlreadyNonNull);}this.newHeads = newHeads;}