public RenderUiTemplateResult renderUiTemplate(RenderUiTemplateRequest request) {request = beforeClientExecution(request);return executeRenderUiTemplate(request);}

public virtual RenderUiTemplateResponse RenderUiTemplate(RenderUiTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = RenderUiTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = RenderUiTemplateResponseUnmarshaller.Instance;return Invoke<RenderUiTemplateResponse>(request, options);}

[User] public RenderUiTemplateResult renderUiTemplate(RenderUiTemplateRequest request) {request = beforeClientExecution(request);return executeRenderUiTemplate(request);}

[Assistant] public virtual RenderUiTemplateResponse RenderUiTemplate(RenderUiTemplateRequest request){var options = new InvokeOptions();options.RequestMarshaller = RenderUiTemplateRequestMarshaller.Instance;options.ResponseUnmarshaller = RenderUiTemplateResponseUnmarshaller.Instance;return Invoke<RenderUiTemplateResponse>(request, options);}


public final LongBuffer asLongBuffer() {return LongToByteBufferAdapter.asLongBuffer(this);}

public sealed override java.nio.LongBuffer asLongBuffer(){return java.nio.LongToByteBufferAdapter.asLongBuffer(this);}

[User] public final LongBuffer asLongBuffer() {return LongToByteBufferAdapter.asLongBuffer(this);}

[Assistant] public sealed override java.nio.LongBuffer asLongBuffer(){return java.nio.LongToByteBufferAdapter.asLongBuffer(this);}


public DescribeLimitsResult describeLimits(DescribeLimitsRequest request) {request = beforeClientExecution(request);return executeDescribeLimits(request);}

public virtual DescribeLimitsResponse DescribeLimits(DescribeLimitsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLimitsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLimitsResponseUnmarshaller.Instance;return Invoke<DescribeLimitsResponse>(request, options);}

[User] public DescribeLimitsResult describeLimits(DescribeLimitsRequest request) {request = beforeClientExecution(request);return executeDescribeLimits(request);}

[Assistant] public virtual DescribeLimitsResponse DescribeLimits(DescribeLimitsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLimitsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLimitsResponseUnmarshaller.Instance;return Invoke<DescribeLimitsResponse>(request, options);}


public DescribeAssessmentTargetsResult describeAssessmentTargets(DescribeAssessmentTargetsRequest request) {request = beforeClientExecution(request);return executeDescribeAssessmentTargets(request);}

public virtual DescribeAssessmentTargetsResponse DescribeAssessmentTargets(DescribeAssessmentTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAssessmentTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAssessmentTargetsResponseUnmarshaller.Instance;return Invoke<DescribeAssessmentTargetsResponse>(request, options);}

[User] public DescribeAssessmentTargetsResult describeAssessmentTargets(DescribeAssessmentTargetsRequest request) {request = beforeClientExecution(request);return executeDescribeAssessmentTargets(request);}

[Assistant] public virtual DescribeAssessmentTargetsResponse DescribeAssessmentTargets(DescribeAssessmentTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAssessmentTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAssessmentTargetsResponseUnmarshaller.Instance;return Invoke<DescribeAssessmentTargetsResponse>(request, options);}


public DeleteClientVpnRouteResult deleteClientVpnRoute(DeleteClientVpnRouteRequest request) {request = beforeClientExecution(request);return executeDeleteClientVpnRoute(request);}

public virtual DeleteClientVpnRouteResponse DeleteClientVpnRoute(DeleteClientVpnRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteClientVpnRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteClientVpnRouteResponseUnmarshaller.Instance;return Invoke<DeleteClientVpnRouteResponse>(request, options);}

[User] public DeleteClientVpnRouteResult deleteClientVpnRoute(DeleteClientVpnRouteRequest request) {request = beforeClientExecution(request);return executeDeleteClientVpnRoute(request);}

[Assistant] public virtual DeleteClientVpnRouteResponse DeleteClientVpnRoute(DeleteClientVpnRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteClientVpnRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteClientVpnRouteResponseUnmarshaller.Instance;return Invoke<DeleteClientVpnRouteResponse>(request, options);}


public RebaseCommand setUpstream(AnyObjectId upstream) {try {this.upstreamCommit = walk.parseCommit(upstream);this.upstreamCommitName = upstream.name();} catch (IOException e) {throw new JGitInternalException(MessageFormat.format(JGitText.get().couldNotReadObjectWhileParsingCommit,upstream.name()), e);}return this;}

public virtual NGit.Api.RebaseCommand SetUpstream(AnyObjectId upstream){try{this.upstreamCommit = walk.ParseCommit(upstream);this.upstreamCommitName = upstream.Name;}catch (IOException e){throw new JGitInternalException(MessageFormat.Format(JGitText.Get().couldNotReadObjectWhileParsingCommit, upstream.Name), e);}return this;}

[User] public RebaseCommand setUpstream(AnyObjectId upstream) {try {this.upstreamCommit = walk.parseCommit(upstream);this.upstreamCommitName = upstream.name();} catch (IOException e) {throw new JGitInternalException(MessageFormat.format(JGitText.get().couldNotReadObjectWhileParsingCommit,upstream.name()), e);}return this;}

[Assistant] public virtual NGit.Api.RebaseCommand SetUpstream(AnyObjectId upstream){try{this.upstreamCommit = walk.ParseCommit(upstream);this.upstreamCommitName = upstream.Name;}catch (IOException e){throw new JGitInternalException(MessageFormat.Format(JGitText.Get().couldNotReadObjectWhileParsingCommit, upstream.Name), e);}return this;}


public Collection<ChildScorable> getChildren() {return Collections.singleton(new ChildScorable(in, "CACHED"));}

public override ICollection<ChildScorer> GetChildren(){return new[] { new ChildScorer(scorer, "CACHED") };}

[User] public Collection<ChildScorable> getChildren() {return Collections.singleton(new ChildScorable(in, "CACHED"));}

[Assistant] public override ICollection<ChildScorer> GetChildren(){return new[] { new ChildScorer(scorer, "CACHED") };}


public synchronized String substring(int start) {return super.substring(start);}

public override string substring(int start){lock (this){return base.substring(start);}}

[User] public synchronized String substring(int start) {return super.substring(start);}

[Assistant] public override string substring(int start){lock (this){return base.substring(start);}}


public static double sum(double[] values) {double sum = 0;for (double value : values) {sum += value;}return sum;}

public static double Sum(double[] values){double sum = 0;for (int i = 0, iSize = values.Length; i < iSize; i++){sum += values[i];}return sum;}

[User] public static double sum(double[] values) {double sum = 0;for (double value : values) {sum += value;}return sum;}

[Assistant] public static double Sum(double[] values){double sum = 0;for (int i = 0, iSize = values.Length; i < iSize; i++){sum += values[i];}return sum;}


public static BlankRecord[] convertBlankRecords(MulBlankRecord mbk) {BlankRecord[] mulRecs = new BlankRecord[mbk.getNumColumns()];for (int k = 0; k < mbk.getNumColumns(); k++) {BlankRecord br = new BlankRecord();br.setColumn((short) (k + mbk.getFirstColumn()));br.setRow(mbk.getRow());br.setXFIndex(mbk.getXFAt(k));mulRecs[k] = br;}return mulRecs;}

public static BlankRecord[] ConvertBlankRecords(MulBlankRecord mbk){BlankRecord[] mulRecs = new BlankRecord[mbk.NumColumns];for (int k = 0; k < mbk.NumColumns; k++){BlankRecord br = new BlankRecord();br.Column = k + mbk.FirstColumn;br.Row = mbk.Row;br.XFIndex = mbk.GetXFAt(k);mulRecs[k] = br;}return mulRecs;}

[User] public static BlankRecord[] convertBlankRecords(MulBlankRecord mbk) {BlankRecord[] mulRecs = new BlankRecord[mbk.getNumColumns()];for (int k = 0; k < mbk.getNumColumns(); k++) {BlankRecord br = new BlankRecord();br.setColumn((short) (k + mbk.getFirstColumn()));br.setRow(mbk.getRow());br.setXFIndex(mbk.getXFAt(k));mulRecs[k] = br;}return mulRecs;}

[Assistant] public static BlankRecord[] ConvertBlankRecords(MulBlankRecord mbk){BlankRecord[] mulRecs = new BlankRecord[mbk.NumColumns];for (int k = 0; k < mbk.NumColumns; k++){BlankRecord br = new BlankRecord();br.Column = k + mbk.FirstColumn;br.Row = mbk.Row;br.XFIndex = mbk.GetXFAt(k);mulRecs[k] = br;}return mulRecs;}


public DeregisterDBProxyTargetsResult deregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request) {request = beforeClientExecution(request);return executeDeregisterDBProxyTargets(request);}

public virtual DeregisterDBProxyTargetsResponse DeregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterDBProxyTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterDBProxyTargetsResponseUnmarshaller.Instance;return Invoke<DeregisterDBProxyTargetsResponse>(request, options);}

[User] public DeregisterDBProxyTargetsResult deregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request) {request = beforeClientExecution(request);return executeDeregisterDBProxyTargets(request);}

[Assistant] public virtual DeregisterDBProxyTargetsResponse DeregisterDBProxyTargets(DeregisterDBProxyTargetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeregisterDBProxyTargetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeregisterDBProxyTargetsResponseUnmarshaller.Instance;return Invoke<DeregisterDBProxyTargetsResponse>(request, options);}


public SummaryInformation(final PropertySet ps) throws UnexpectedPropertySetTypeException {super(ps);if (!isSummaryInformation()) {throw new UnexpectedPropertySetTypeException("Not a " + getClass().getName());}}

public SummaryInformation(PropertySet ps): base(ps){if (!IsSummaryInformation)throw new UnexpectedPropertySetTypeException("Not a "+ GetType().Name);}

[User] public SummaryInformation(final PropertySet ps) throws UnexpectedPropertySetTypeException {super(ps);if (!isSummaryInformation()) {throw new UnexpectedPropertySetTypeException("Not a " + getClass().getName());}}

[Assistant] public SummaryInformation(PropertySet ps): base(ps){if (!IsSummaryInformation)throw new UnexpectedPropertySetTypeException("Not a "+ GetType().Name);}


public void setCredentialsProvider(AlibabaCloudCredentialsProvider credentialsProvider) {if (credential != null) {return;}credential = new CredentialsBackupCompatibilityAdaptor(credentialsProvider);}

public void SetCredentialsProvider(AlibabaCloudCredentialsProvider credentialsProvider){if (_credential != null){return;}_credential = new CredentialsBackupCompatibilityAdaptor(credentialsProvider);}

[User] public void setCredentialsProvider(AlibabaCloudCredentialsProvider credentialsProvider) {if (credential != null) {return;}credential = new CredentialsBackupCompatibilityAdaptor(credentialsProvider);}

[Assistant] public void SetCredentialsProvider(AlibabaCloudCredentialsProvider credentialsProvider){if (_credential != null){return;}_credential = new CredentialsBackupCompatibilityAdaptor(credentialsProvider);}


public CharArrayReader(char[] buf, int offset, int length) {if (offset < 0 || offset > buf.length || length < 0 || offset + length < 0) {throw new IllegalArgumentException();}this.buf = buf;this.pos = offset;this.markedPos = offset;int bufferLength = buf.length;this.count = offset + length < bufferLength ? length : bufferLength;}

public CharArrayReader(char[] buf, int offset, int length){if (offset < 0 || offset > buf.Length || length < 0 || offset + length < 0){throw new System.ArgumentException();}this.buf = buf;this.pos = offset;this.markedPos = offset;int bufferLength = buf.Length;this.count = offset + length < bufferLength ? length : bufferLength;}

[User] public CharArrayReader(char[] buf, int offset, int length) {if (offset < 0 || offset > buf.length || length < 0 || offset + length < 0) {throw new IllegalArgumentException();}this.buf = buf;this.pos = offset;this.markedPos = offset;int bufferLength = buf.length;this.count = offset + length < bufferLength ? length : bufferLength;}

[Assistant] public CharArrayReader(char[] buf, int offset, int length){if (offset < 0 || offset > buf.Length || length < 0 || offset + length < 0){throw new System.ArgumentException();}this.buf = buf;this.pos = offset;this.markedPos = offset;int bufferLength = buf.Length;this.count = offset + length < bufferLength ? length : bufferLength;}


public Object getProperty(final long id) {wasNull = !properties.containsKey(id);return (wasNull) ? null : properties.get(id).getValue();}

public virtual Object GetProperty(long id){wasNull = false;for (int i = 0; i < properties.Length; i++)if (id == properties[i].ID)return properties[i].Value;wasNull = true;return null;}

[User] public Object getProperty(final long id) {wasNull = !properties.containsKey(id);return (wasNull) ? null : properties.get(id).getValue();}

[Assistant] public virtual Object GetProperty(long id){wasNull = false;for (int i = 0; i < properties.Length; i++)if (id == properties[i].ID)return properties[i].Value;wasNull = true;return null;}


public BufferedOutputStream(OutputStream out, int size) {super(out);if (size <= 0) {throw new IllegalArgumentException("size <= 0");}buf = new byte[size];}

public BufferedOutputStream(java.io.OutputStream @out, int size) : base(@out){if (size <= 0){throw new System.ArgumentException("size <= 0");}buf = new byte[size];}

[User] public BufferedOutputStream(OutputStream out, int size) {super(out);if (size <= 0) {throw new IllegalArgumentException("size <= 0");}buf = new byte[size];}

[Assistant] public BufferedOutputStream(java.io.OutputStream @out, int size) : base(@out){if (size <= 0){throw new System.ArgumentException("size <= 0");}buf = new byte[size];}


public AuthorizeDBSecurityGroupIngressRequest(String dBSecurityGroupName) {setDBSecurityGroupName(dBSecurityGroupName);}

public AuthorizeDBSecurityGroupIngressRequest(string dbSecurityGroupName){_dbSecurityGroupName = dbSecurityGroupName;}

[User] public AuthorizeDBSecurityGroupIngressRequest(String dBSecurityGroupName) {setDBSecurityGroupName(dBSecurityGroupName);}

[Assistant] public AuthorizeDBSecurityGroupIngressRequest(string dbSecurityGroupName){_dbSecurityGroupName = dbSecurityGroupName;}


public ArrayDataSource(T[] elements) {this.elements = elements.clone();}

public ArrayDataSource(T[] elements) {this.elements = elements;}

[User] public ArrayDataSource(T[] elements) {this.elements = elements.clone();}

[Assistant] public ArrayDataSource(T[] elements) {this.elements = elements;}


public CreateDeploymentResult createDeployment(CreateDeploymentRequest request) {request = beforeClientExecution(request);return executeCreateDeployment(request);}

public virtual CreateDeploymentResponse CreateDeployment(CreateDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDeploymentResponseUnmarshaller.Instance;return Invoke<CreateDeploymentResponse>(request, options);}

[User] public CreateDeploymentResult createDeployment(CreateDeploymentRequest request) {request = beforeClientExecution(request);return executeCreateDeployment(request);}

[Assistant] public virtual CreateDeploymentResponse CreateDeployment(CreateDeploymentRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateDeploymentRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateDeploymentResponseUnmarshaller.Instance;return Invoke<CreateDeploymentResponse>(request, options);}


public final int getInt() {int newPosition = position + SizeOf.INT;if (newPosition > limit) {throw new BufferUnderflowException();}int result = Memory.peekInt(backingArray, offset + position, order);position = newPosition;return result;}

public sealed override int getInt(){int newPosition = _position + libcore.io.SizeOf.INT;if (newPosition > _limit){throw new java.nio.BufferUnderflowException();}int result = libcore.io.Memory.peekInt(backingArray, offset + _position, _order);_position = newPosition;return result;}

[User] public final int getInt() {int newPosition = position + SizeOf.INT;if (newPosition > limit) {throw new BufferUnderflowException();}int result = Memory.peekInt(backingArray, offset + position, order);position = newPosition;return result;}

[Assistant] public sealed override int getInt(){int newPosition = _position + libcore.io.SizeOf.INT;if (newPosition > _limit){throw new java.nio.BufferUnderflowException();}int result = libcore.io.Memory.peekInt(backingArray, offset + _position, _order);_position = newPosition;return result;}


public DeleteTransitGatewayRouteResult deleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request) {request = beforeClientExecution(request);return executeDeleteTransitGatewayRoute(request);}

public virtual DeleteTransitGatewayRouteResponse DeleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTransitGatewayRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTransitGatewayRouteResponseUnmarshaller.Instance;return Invoke<DeleteTransitGatewayRouteResponse>(request, options);}

[User] public DeleteTransitGatewayRouteResult deleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request) {request = beforeClientExecution(request);return executeDeleteTransitGatewayRoute(request);}

[Assistant] public virtual DeleteTransitGatewayRouteResponse DeleteTransitGatewayRoute(DeleteTransitGatewayRouteRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteTransitGatewayRouteRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteTransitGatewayRouteResponseUnmarshaller.Instance;return Invoke<DeleteTransitGatewayRouteResponse>(request, options);}


public ListMultipartUploadsRequest(String bucketName) {this.bucketName = bucketName;}

public ListMultipartUploadsRequest(string vaultName){_vaultName = vaultName;}

[User] public ListMultipartUploadsRequest(String bucketName) {this.bucketName = bucketName;}

[Assistant] public ListMultipartUploadsRequest(string vaultName){_vaultName = vaultName;}


public float score(float freq, long norm) {return (float) SimilarityBase.this.score(stats, freq, getLengthValue(norm));}

public override float Score(int doc, float freq){return outerInstance.Score(stats, freq, norms == null ? 1F : outerInstance.DecodeNormValue((byte)norms.Get(doc)));}

[User] public float score(float freq, long norm) {return (float) SimilarityBase.this.score(stats, freq, getLengthValue(norm));}

[Assistant] public override float Score(int doc, float freq){return outerInstance.Score(stats, freq, norms == null ? 1F : outerInstance.DecodeNormValue((byte)norms.Get(doc)));}


public char next() {if (offset >= (end - 1)) {offset = end;return DONE;}return string.charAt(++offset);}

public char next(){if (offset >= (end - 1)){offset = end;return java.text.CharacterIteratorClass.DONE;}return @string[++offset];}

[User] public char next() {if (offset >= (end - 1)) {offset = end;return DONE;}return string.charAt(++offset);}

[Assistant] public char next(){if (offset >= (end - 1)){offset = end;return java.text.CharacterIteratorClass.DONE;}return @string[++offset];}


public CherryPickResult(RevCommit newHead, List<Ref> cherryPickedRefs) {this.status = CherryPickStatus.OK;this.newHead = newHead;this.cherryPickedRefs = cherryPickedRefs;this.failingPaths = null;}

public CherryPickResult(RevCommit newHead, IList<Ref> cherryPickedRefs){this.status = CherryPickResult.CherryPickStatus.OK;this.newHead = newHead;this.cherryPickedRefs = cherryPickedRefs;this.failingPaths = null;}

[User] public CherryPickResult(RevCommit newHead, List<Ref> cherryPickedRefs) {this.status = CherryPickStatus.OK;this.newHead = newHead;this.cherryPickedRefs = cherryPickedRefs;this.failingPaths = null;}

[Assistant] public CherryPickResult(RevCommit newHead, IList<Ref> cherryPickedRefs){this.status = CherryPickResult.CherryPickStatus.OK;this.newHead = newHead;this.cherryPickedRefs = cherryPickedRefs;this.failingPaths = null;}


public static Token newToken(int ofKind){return newToken(ofKind, null);}

public static Token NewToken(int ofKind){return NewToken(ofKind, null);}

[User] public static Token newToken(int ofKind){return newToken(ofKind, null);}

[Assistant] public static Token NewToken(int ofKind){return NewToken(ofKind, null);}


public HSSFClientAnchor getPreferredSize(double scale){return getPreferredSize(scale, scale);}

public IClientAnchor GetPreferredSize(double scale){return GetPreferredSize(scale, scale);}

[User] public HSSFClientAnchor getPreferredSize(double scale){return getPreferredSize(scale, scale);}

[Assistant] public IClientAnchor GetPreferredSize(double scale){return GetPreferredSize(scale, scale);}


public UpdateInstanceRequest() {super("Ots", "2016-06-20", "UpdateInstance", "ots");setMethod(MethodType.POST);}

public UpdateInstanceRequest(): base("Ots", "2016-06-20", "UpdateInstance", "ots", "openAPI"){Method = MethodType.POST;}

[User] public UpdateInstanceRequest() {super("Ots", "2016-06-20", "UpdateInstance", "ots");setMethod(MethodType.POST);}

[Assistant] public UpdateInstanceRequest(): base("Ots", "2016-06-20", "UpdateInstance", "ots", "openAPI"){Method = MethodType.POST;}


public ByteBuffer putInt(int index, int value) {checkIndex(index, SizeOf.INT);Memory.pokeInt(backingArray, offset + index, value, order);return this;}

public override java.nio.ByteBuffer putInt(int index, int value){checkIndex(index, libcore.io.SizeOf.INT);libcore.io.Memory.pokeInt(backingArray, offset + index, value, _order);return this;}

[User] public ByteBuffer putInt(int index, int value) {checkIndex(index, SizeOf.INT);Memory.pokeInt(backingArray, offset + index, value, order);return this;}

[Assistant] public override java.nio.ByteBuffer putInt(int index, int value){checkIndex(index, libcore.io.SizeOf.INT);libcore.io.Memory.pokeInt(backingArray, offset + index, value, _order);return this;}


public byte[] serialize() {int size = getDataSize() + 4;ByteArrayOutputStream baos = new ByteArrayOutputStream(size);serialize(new LittleEndianOutputStream(baos));if (baos.size() != size) {throw new RuntimeException("write size mismatch");}return baos.toByteArray();}

public byte[] Serialize(){int size = DataSize + 4;using (MemoryStream baos = new MemoryStream(size)){Serialize(new LittleEndianOutputStream(baos));if (baos.Length != size){throw new Exception("write size mismatch");}return baos.ToArray();}}

[User] public byte[] serialize() {int size = getDataSize() + 4;ByteArrayOutputStream baos = new ByteArrayOutputStream(size);serialize(new LittleEndianOutputStream(baos));if (baos.size() != size) {throw new RuntimeException("write size mismatch");}return baos.toByteArray();}

[Assistant] public byte[] Serialize(){int size = DataSize + 4;using (MemoryStream baos = new MemoryStream(size)){Serialize(new LittleEndianOutputStream(baos));if (baos.Length != size){throw new Exception("write size mismatch");}return baos.ToArray();}}


public GetFieldLevelEncryptionProfileResult getFieldLevelEncryptionProfile(GetFieldLevelEncryptionProfileRequest request) {request = beforeClientExecution(request);return executeGetFieldLevelEncryptionProfile(request);}

public virtual GetFieldLevelEncryptionProfileResponse GetFieldLevelEncryptionProfile(GetFieldLevelEncryptionProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFieldLevelEncryptionProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFieldLevelEncryptionProfileResponseUnmarshaller.Instance;return Invoke<GetFieldLevelEncryptionProfileResponse>(request, options);}

[User] public GetFieldLevelEncryptionProfileResult getFieldLevelEncryptionProfile(GetFieldLevelEncryptionProfileRequest request) {request = beforeClientExecution(request);return executeGetFieldLevelEncryptionProfile(request);}

[Assistant] public virtual GetFieldLevelEncryptionProfileResponse GetFieldLevelEncryptionProfile(GetFieldLevelEncryptionProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFieldLevelEncryptionProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFieldLevelEncryptionProfileResponseUnmarshaller.Instance;return Invoke<GetFieldLevelEncryptionProfileResponse>(request, options);}


public void serialize(LittleEndianOutput out) {out.writeShort(field_1_number_of_sheets);if(isExternalReferences()) {StringUtil.writeUnicodeString(out, field_2_encoded_url);for (String field_3_sheet_name : field_3_sheet_names) {StringUtil.writeUnicodeString(out, field_3_sheet_name);}} else {int field2val = _isAddInFunctions ? TAG_ADD_IN_FUNCTIONS : TAG_INTERNAL_REFERENCES;out.writeShort(field2val);}}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_number_of_sheets);if (IsExternalReferences){StringUtil.WriteUnicodeString(out1, field_2_encoded_url);for (int i = 0; i < field_3_sheet_names.Length; i++){StringUtil.WriteUnicodeString(out1, field_3_sheet_names[i]);}}else{int field2val = _isAddInFunctions ? TAG_ADD_IN_FUNCTIONS : TAG_INTERNAL_REFERENCES;out1.WriteShort(field2val);}}

[User] public void serialize(LittleEndianOutput out) {out.writeShort(field_1_number_of_sheets);if(isExternalReferences()) {StringUtil.writeUnicodeString(out, field_2_encoded_url);for (String field_3_sheet_name : field_3_sheet_names) {StringUtil.writeUnicodeString(out, field_3_sheet_name);}} else {int field2val = _isAddInFunctions ? TAG_ADD_IN_FUNCTIONS : TAG_INTERNAL_REFERENCES;out.writeShort(field2val);}}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_number_of_sheets);if (IsExternalReferences){StringUtil.WriteUnicodeString(out1, field_2_encoded_url);for (int i = 0; i < field_3_sheet_names.Length; i++){StringUtil.WriteUnicodeString(out1, field_3_sheet_names[i]);}}else{int field2val = _isAddInFunctions ? TAG_ADD_IN_FUNCTIONS : TAG_INTERNAL_REFERENCES;out1.WriteShort(field2val);}}


public BitsSlice(Bits parent, ReaderSlice slice) {this.parent = parent;this.start = slice.start;this.length = slice.length;assert length >= 0: "length=" + length;}

public BitsSlice(IBits parent, ReaderSlice slice){this.parent = parent;this.start = slice.Start;this.length = slice.Length;Debug.Assert(length >= 0, "length=" + length);}

[User] public BitsSlice(Bits parent, ReaderSlice slice) {this.parent = parent;this.start = slice.start;this.length = slice.length;assert length >= 0: "length=" + length;}

[Assistant] public BitsSlice(IBits parent, ReaderSlice slice){this.parent = parent;this.start = slice.Start;this.length = slice.Length;Debug.Assert(length >= 0, "length=" + length);}


public void removeName(Name name) {int index = getNameIndex((HSSFName) name);removeName(index);}

public void RemoveName(int index){names.RemoveAt(index);workbook.RemoveName(index);}

[User] public void removeName(Name name) {int index = getNameIndex((HSSFName) name);removeName(index);}

[Assistant] public void RemoveName(int index){names.RemoveAt(index);workbook.RemoveName(index);}


public ListConfigurationRevisionsResult listConfigurationRevisions(ListConfigurationRevisionsRequest request) {request = beforeClientExecution(request);return executeListConfigurationRevisions(request);}

public virtual ListConfigurationRevisionsResponse ListConfigurationRevisions(ListConfigurationRevisionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListConfigurationRevisionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListConfigurationRevisionsResponseUnmarshaller.Instance;return Invoke<ListConfigurationRevisionsResponse>(request, options);}

[User] public ListConfigurationRevisionsResult listConfigurationRevisions(ListConfigurationRevisionsRequest request) {request = beforeClientExecution(request);return executeListConfigurationRevisions(request);}

[Assistant] public virtual ListConfigurationRevisionsResponse ListConfigurationRevisions(ListConfigurationRevisionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListConfigurationRevisionsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListConfigurationRevisionsResponseUnmarshaller.Instance;return Invoke<ListConfigurationRevisionsResponse>(request, options);}


public ObjectStream openStream() {return new ObjectStream.SmallStream(this);}

public override ObjectStream OpenStream(){return new ObjectStream.SmallStream(this);}

[User] public ObjectStream openStream() {return new ObjectStream.SmallStream(this);}

[Assistant] public override ObjectStream OpenStream(){return new ObjectStream.SmallStream(this);}


public boolean delete() {return directory.delete();}

public bool Delete(){return directory.Delete();}

[User] public boolean delete() {return directory.delete();}

[Assistant] public bool Delete(){return directory.Delete();}


[User] public void clear(){_limit = 0;}

[Assistant] public void Clear(){_limit = 0;}


public void setMaxObjectSizeLimit(long limit) {maxObjectSizeLimit = limit;}

public virtual void SetMaxObjectSizeLimit(long limit){maxObjectSizeLimit = limit;}

[User] public void setMaxObjectSizeLimit(long limit) {maxObjectSizeLimit = limit;}

[Assistant] public virtual void SetMaxObjectSizeLimit(long limit){maxObjectSizeLimit = limit;}


public DescribeEventSubscriptionsResult describeEventSubscriptions(DescribeEventSubscriptionsRequest request) {request = beforeClientExecution(request);return executeDescribeEventSubscriptions(request);}

public virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions(DescribeEventSubscriptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance;return Invoke<DescribeEventSubscriptionsResponse>(request, options);}

[User] public DescribeEventSubscriptionsResult describeEventSubscriptions(DescribeEventSubscriptionsRequest request) {request = beforeClientExecution(request);return executeDescribeEventSubscriptions(request);}

[Assistant] public virtual DescribeEventSubscriptionsResponse DescribeEventSubscriptions(DescribeEventSubscriptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEventSubscriptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEventSubscriptionsResponseUnmarshaller.Instance;return Invoke<DescribeEventSubscriptionsResponse>(request, options);}


public boolean startEvaluate(FormulaCellCacheEntry cce) {if (cce == null) {throw new IllegalArgumentException("cellLoc must not be null");}if (_currentlyEvaluatingCells.contains(cce)) {return false;}_currentlyEvaluatingCells.add(cce);_evaluationFrames.add(new CellEvaluationFrame(cce));return true;}

public bool StartEvaluate(FormulaCellCacheEntry cce){if (cce == null){throw new ArgumentException("cellLoc must not be null");}if (_currentlyEvaluatingCells.Contains(cce)){return false;}_currentlyEvaluatingCells.Add(cce);_evaluationFrames.Add(new CellEvaluationFrame(cce));return true;}

[User] public boolean startEvaluate(FormulaCellCacheEntry cce) {if (cce == null) {throw new IllegalArgumentException("cellLoc must not be null");}if (_currentlyEvaluatingCells.contains(cce)) {return false;}_currentlyEvaluatingCells.add(cce);_evaluationFrames.add(new CellEvaluationFrame(cce));return true;}

[Assistant] public bool StartEvaluate(FormulaCellCacheEntry cce){if (cce == null){throw new ArgumentException("cellLoc must not be null");}if (_currentlyEvaluatingCells.Contains(cce)){return false;}_currentlyEvaluatingCells.Add(cce);_evaluationFrames.Add(new CellEvaluationFrame(cce));return true;}


public void serialize(LittleEndianOutput out) {out.writeShort(sid);out.writeShort(_cbFContinued);if (_linkPtg == null) {out.writeShort(0);} else {int formulaSize = _linkPtg.getSize();int linkSize = formulaSize + 6;if (_unknownPostFormulaByte != null) {linkSize++;}out.writeShort(linkSize);out.writeShort(formulaSize);out.writeInt(_unknownPreFormulaInt);_linkPtg.write(out);if (_unknownPostFormulaByte != null) {out.writeByte(_unknownPostFormulaByte.intValue());}}out.writeShort(_cLines);out.writeShort(_iSel);out.writeShort(_flags);out.writeShort(_idEdit);if(_dropData != null) {_dropData.serialize(out);}if(_rgLines != null) {for(String str : _rgLines){StringUtil.writeUnicodeString(out, str);}}if(_bsels != null) {for(boolean val : _bsels){out.writeByte(val ? 1 : 0);}}}

public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(sid);out1.WriteShort(_cbFContinued); if (_linkPtg == null){out1.WriteShort(0);}else{int formulaSize = _linkPtg.Size;int linkSize = formulaSize + 6;if (_unknownPostFormulaByte != null){linkSize++;}out1.WriteShort(linkSize);out1.WriteShort(formulaSize);out1.WriteInt(_unknownPreFormulaInt);_linkPtg.Write(out1);if (_unknownPostFormulaByte != null){out1.WriteByte(Convert.ToByte(_unknownPostFormulaByte, CultureInfo.InvariantCulture));}}out1.WriteShort(_cLines);out1.WriteShort(_iSel);out1.WriteShort(_flags);out1.WriteShort(_idEdit);if (_dropData != null){_dropData.Serialize(out1);}if (_rgLines != null){foreach (String str in _rgLines){StringUtil.WriteUnicodeString(out1, str);}}if (_bsels != null){foreach (bool val in _bsels){out1.WriteByte(val ? 1 : 0);}}}

[User] public void serialize(LittleEndianOutput out) {out.writeShort(sid);out.writeShort(_cbFContinued);if (_linkPtg == null) {out.writeShort(0);} else {int formulaSize = _linkPtg.getSize();int linkSize = formulaSize + 6;if (_unknownPostFormulaByte != null) {linkSize++;}out.writeShort(linkSize);out.writeShort(formulaSize);out.writeInt(_unknownPreFormulaInt);_linkPtg.write(out);if (_unknownPostFormulaByte != null) {out.writeByte(_unknownPostFormulaByte.intValue());}}out.writeShort(_cLines);out.writeShort(_iSel);out.writeShort(_flags);out.writeShort(_idEdit);if(_dropData != null) {_dropData.serialize(out);}if(_rgLines != null) {for(String str : _rgLines){StringUtil.writeUnicodeString(out, str);}}if(_bsels != null) {for(boolean val : _bsels){out.writeByte(val ? 1 : 0);}}}

[Assistant] public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(sid);out1.WriteShort(_cbFContinued); if (_linkPtg == null){out1.WriteShort(0);}else{int formulaSize = _linkPtg.Size;int linkSize = formulaSize + 6;if (_unknownPostFormulaByte != null){linkSize++;}out1.WriteShort(linkSize);out1.WriteShort(formulaSize);out1.WriteInt(_unknownPreFormulaInt);_linkPtg.Write(out1);if (_unknownPostFormulaByte != null){out1.WriteByte(Convert.ToByte(_unknownPostFormulaByte, CultureInfo.InvariantCulture));}}out1.WriteShort(_cLines);out1.WriteShort(_iSel);out1.WriteShort(_flags);out1.WriteShort(_idEdit);if (_dropData != null){_dropData.Serialize(out1);}if (_rgLines != null){foreach (String str in _rgLines){StringUtil.WriteUnicodeString(out1, str);}}if (_bsels != null){foreach (bool val in _bsels){out1.WriteByte(val ? 1 : 0);}}}


public void remove(int el) {if ( readonly ) throw new IllegalStateException("can't alter readonly IntervalSet");int n = intervals.size();for (int i = 0; i < n; i++) {Interval I = intervals.get(i);int a = I.a;int b = I.b;if ( el<a ) {break; }if ( el==a && el==b ) {intervals.remove(i);break;}if ( el==a ) {I.a++;break;}if ( el==b ) {I.b--;break;}if ( el>a && el<b ) { int oldb = I.b;I.b = el-1;      add(el+1, oldb); }}}

public virtual void Remove(int el){if (@readonly){throw new InvalidOperationException("can't alter readonly IntervalSet");}int n = intervals.Count;for (int i = 0; i < n; i++){Interval I = intervals[i];int a = I.a;int b = I.b;if (el < a){break;}if (el == a && el == b){intervals.RemoveAt(i);break;}if (el == a){intervals[i] = Interval.Of(I.a + 1, I.b);break;}if (el == b){intervals[i] = Interval.Of(I.a, I.b - 1);break;}if (el > a && el < b){int oldb = I.b;intervals[i] = Interval.Of(I.a, el - 1);Add(el + 1, oldb);}}}

[User] public void remove(int el) {if ( readonly ) throw new IllegalStateException("can't alter readonly IntervalSet");int n = intervals.size();for (int i = 0; i < n; i++) {Interval I = intervals.get(i);int a = I.a;int b = I.b;if ( el<a ) {break; }if ( el==a && el==b ) {intervals.remove(i);break;}if ( el==a ) {I.a++;break;}if ( el==b ) {I.b--;break;}if ( el>a && el<b ) { int oldb = I.b;I.b = el-1;      add(el+1, oldb); }}}

[Assistant] public virtual void Remove(int el){if (@readonly){throw new InvalidOperationException("can't alter readonly IntervalSet");}int n = intervals.Count;for (int i = 0; i < n; i++){Interval I = intervals[i];int a = I.a;int b = I.b;if (el < a){break;}if (el == a && el == b){intervals.RemoveAt(i);break;}if (el == a){intervals[i] = Interval.Of(I.a + 1, I.b);break;}if (el == b){intervals[i] = Interval.Of(I.a, I.b - 1);break;}if (el > a && el < b){int oldb = I.b;intervals[i] = Interval.Of(I.a, el - 1);Add(el + 1, oldb);}}}


public IntegerList toIntegerList() {IntegerList values = new IntegerList(size());int n = intervals.size();for (int i = 0; i < n; i++) {Interval I = intervals.get(i);int a = I.a;int b = I.b;for (int v=a; v<=b; v++) {values.add(v);}}return values;}

public virtual ArrayList<int> ToIntegerList(){ArrayList<int> values = new ArrayList<int>(Count);int n = intervals.Count;for (int i = 0; i < n; i++){Interval I = intervals[i];int a = I.a;int b = I.b;for (int v = a; v <= b; v++){values.Add(v);}}return values;}

[User] public IntegerList toIntegerList() {IntegerList values = new IntegerList(size());int n = intervals.size();for (int i = 0; i < n; i++) {Interval I = intervals.get(i);int a = I.a;int b = I.b;for (int v=a; v<=b; v++) {values.add(v);}}return values;}

[Assistant] public virtual ArrayList<int> ToIntegerList(){ArrayList<int> values = new ArrayList<int>(Count);int n = intervals.Count;for (int i = 0; i < n; i++){Interval I = intervals[i];int a = I.a;int b = I.b;for (int v = a; v <= b; v++){values.Add(v);}}return values;}


@Override public void clear() {AbstractMultimap.this.clear();}

public override void clear(){this._enclosing.clear();}

[User] @Override public void clear() {AbstractMultimap.this.clear();}

[Assistant] public override void clear(){this._enclosing.clear();}


public CharsRef pullNext() {assert upto < count;lastEndOffset = endOffsets[upto];lastPosLength = posLengths[upto];final CharsRefBuilder result = outputs[upto++];posIncr = 0;if (upto == count) {reset();}return result.get();}

public virtual CharsRef PullNext(){Debug.Assert(upto < count);lastEndOffset = endOffsets[upto];lastPosLength = posLengths[upto];CharsRef result = outputs[upto++];posIncr = 0;if (upto == count){Reset();}return result;}

[User] public CharsRef pullNext() {assert upto < count;lastEndOffset = endOffsets[upto];lastPosLength = posLengths[upto];final CharsRefBuilder result = outputs[upto++];posIncr = 0;if (upto == count) {reset();}return result.get();}

[Assistant] public virtual CharsRef PullNext(){Debug.Assert(upto < count);lastEndOffset = endOffsets[upto];lastPosLength = posLengths[upto];CharsRef result = outputs[upto++];posIncr = 0;if (upto == count){Reset();}return result;}


public FSTTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter) throws IOException {final String termsFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_EXTENSION);this.postingsWriter = postingsWriter;this.fieldInfos = state.fieldInfos;this.out = state.directory.createOutput(termsFileName, state.context);this.maxDoc = state.segmentInfo.maxDoc();boolean success = false;try {CodecUtil.writeIndexHeader(out, TERMS_CODEC_NAME, TERMS_VERSION_CURRENT,state.segmentInfo.getId(), state.segmentSuffix);this.postingsWriter.init(out, state);success = true;} finally {if (!success) {IOUtils.closeWhileHandlingException(out);}}}

public FSTTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter){var termsFileName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name, state.SegmentSuffix,TERMS_EXTENSION);_postingsWriter = postingsWriter;_fieldInfos = state.FieldInfos;_output = state.Directory.CreateOutput(termsFileName, state.Context);var success = false;try{WriteHeader(_output);_postingsWriter.Init(_output);success = true;}finally{if (!success){IOUtils.DisposeWhileHandlingException(_output);}}}

[User] public FSTTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter) throws IOException {final String termsFileName = IndexFileNames.segmentFileName(state.segmentInfo.name, state.segmentSuffix, TERMS_EXTENSION);this.postingsWriter = postingsWriter;this.fieldInfos = state.fieldInfos;this.out = state.directory.createOutput(termsFileName, state.context);this.maxDoc = state.segmentInfo.maxDoc();boolean success = false;try {CodecUtil.writeIndexHeader(out, TERMS_CODEC_NAME, TERMS_VERSION_CURRENT,state.segmentInfo.getId(), state.segmentSuffix);this.postingsWriter.init(out, state);success = true;} finally {if (!success) {IOUtils.closeWhileHandlingException(out);}}}

[Assistant] public FSTTermsWriter(SegmentWriteState state, PostingsWriterBase postingsWriter){var termsFileName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name, state.SegmentSuffix,TERMS_EXTENSION);_postingsWriter = postingsWriter;_fieldInfos = state.FieldInfos;_output = state.Directory.CreateOutput(termsFileName, state.Context);var success = false;try{WriteHeader(_output);_postingsWriter.Init(_output);success = true;}finally{if (!success){IOUtils.DisposeWhileHandlingException(_output);}}}


public int compareTo(Cell other) {return Double.compare(distanceSortKey, other.distanceSortKey);}

public virtual int CompareTo(Cell o){return string.CompareOrdinal(TokenString, o.TokenString);}

[User] public int compareTo(Cell other) {return Double.compare(distanceSortKey, other.distanceSortKey);}

[Assistant] public virtual int CompareTo(Cell o){return string.CompareOrdinal(TokenString, o.TokenString);}


public ListAccountSettingsResult listAccountSettings(ListAccountSettingsRequest request) {request = beforeClientExecution(request);return executeListAccountSettings(request);}

public virtual ListAccountSettingsResponse ListAccountSettings(ListAccountSettingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAccountSettingsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAccountSettingsResponseUnmarshaller.Instance;return Invoke<ListAccountSettingsResponse>(request, options);}

[User] public ListAccountSettingsResult listAccountSettings(ListAccountSettingsRequest request) {request = beforeClientExecution(request);return executeListAccountSettings(request);}

[Assistant] public virtual ListAccountSettingsResponse ListAccountSettings(ListAccountSettingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListAccountSettingsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListAccountSettingsResponseUnmarshaller.Instance;return Invoke<ListAccountSettingsResponse>(request, options);}


public boolean find() {matchFound = findNextImpl(address, input, matchOffsets);if (matchFound) {findPos = matchOffsets[1];}return matchFound;}

public bool find(){matchFound = findNextImpl(address, input, matchOffsets);if (matchFound){findPos = matchOffsets[1];}return matchFound;}

[User] public boolean find() {matchFound = findNextImpl(address, input, matchOffsets);if (matchFound) {findPos = matchOffsets[1];}return matchFound;}

[Assistant] public bool find(){matchFound = findNextImpl(address, input, matchOffsets);if (matchFound){findPos = matchOffsets[1];}return matchFound;}


public V next()        { return super.nextEntry().value; }

public override V next(){return this.nextEntry().value;}

[User] public V next()        { return super.nextEntry().value; }

[Assistant] public override V next(){return this.nextEntry().value;}


public DescribeLocalGatewaysResult describeLocalGateways(DescribeLocalGatewaysRequest request) {request = beforeClientExecution(request);return executeDescribeLocalGateways(request);}

public virtual DescribeLocalGatewaysResponse DescribeLocalGateways(DescribeLocalGatewaysRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLocalGatewaysRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLocalGatewaysResponseUnmarshaller.Instance;return Invoke<DescribeLocalGatewaysResponse>(request, options);}

[User] public DescribeLocalGatewaysResult describeLocalGateways(DescribeLocalGatewaysRequest request) {request = beforeClientExecution(request);return executeDescribeLocalGateways(request);}

[Assistant] public virtual DescribeLocalGatewaysResponse DescribeLocalGateways(DescribeLocalGatewaysRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeLocalGatewaysRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeLocalGatewaysResponseUnmarshaller.Instance;return Invoke<DescribeLocalGatewaysResponse>(request, options);}


public ByteArrayDataInput(byte[] bytes, int offset, int len) {reset(bytes, offset, len);}

public ByteArrayDataInput(byte[] bytes, int offset, int len){Reset(bytes, offset, len);}

[User] public ByteArrayDataInput(byte[] bytes, int offset, int len) {reset(bytes, offset, len);}

[Assistant] public ByteArrayDataInput(byte[] bytes, int offset, int len){Reset(bytes, offset, len);}


public String toString() {return super.toString() + ":" + revstr; }

public override string ToString(){return base.ToString() + ":" + revstr;}

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

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


public RegisterCrossAccountAccessRoleResult registerCrossAccountAccessRole(RegisterCrossAccountAccessRoleRequest request) {request = beforeClientExecution(request);return executeRegisterCrossAccountAccessRole(request);}

public virtual RegisterCrossAccountAccessRoleResponse RegisterCrossAccountAccessRole(RegisterCrossAccountAccessRoleRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterCrossAccountAccessRoleRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterCrossAccountAccessRoleResponseUnmarshaller.Instance;return Invoke<RegisterCrossAccountAccessRoleResponse>(request, options);}

[User] public RegisterCrossAccountAccessRoleResult registerCrossAccountAccessRole(RegisterCrossAccountAccessRoleRequest request) {request = beforeClientExecution(request);return executeRegisterCrossAccountAccessRole(request);}

[Assistant] public virtual RegisterCrossAccountAccessRoleResponse RegisterCrossAccountAccessRole(RegisterCrossAccountAccessRoleRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterCrossAccountAccessRoleRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterCrossAccountAccessRoleResponseUnmarshaller.Instance;return Invoke<RegisterCrossAccountAccessRoleResponse>(request, options);}


public void clear() {ConcurrentHashMap.this.clear();}

[User] public void clear() {ConcurrentHashMap.this.clear();}

[Assistant] public override void clear(){this._enclosing.clear();}


public DescribeFileSystemsResult describeFileSystems(DescribeFileSystemsRequest request) {request = beforeClientExecution(request);return executeDescribeFileSystems(request);}

public virtual DescribeFileSystemsResponse DescribeFileSystems(DescribeFileSystemsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFileSystemsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFileSystemsResponseUnmarshaller.Instance;return Invoke<DescribeFileSystemsResponse>(request, options);}

[User] public DescribeFileSystemsResult describeFileSystems(DescribeFileSystemsRequest request) {request = beforeClientExecution(request);return executeDescribeFileSystems(request);}

[Assistant] public virtual DescribeFileSystemsResponse DescribeFileSystems(DescribeFileSystemsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeFileSystemsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeFileSystemsResponseUnmarshaller.Instance;return Invoke<DescribeFileSystemsResponse>(request, options);}


public ReverseStringFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public ReverseStringFilterFactory(IDictionary<string, string> args) : base(args){AssureMatchVersion();if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}

[User] public ReverseStringFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public ReverseStringFilterFactory(IDictionary<string, string> args) : base(args){AssureMatchVersion();if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}


[User] public Builder() {this(true);}

[Assistant] public Builder(){InitializeInstanceFields();}


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

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

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

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


public GetQualificationTypeResult getQualificationType(GetQualificationTypeRequest request) {request = beforeClientExecution(request);return executeGetQualificationType(request);}

public virtual GetQualificationTypeResponse GetQualificationType(GetQualificationTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetQualificationTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = GetQualificationTypeResponseUnmarshaller.Instance;return Invoke<GetQualificationTypeResponse>(request, options);}

[User] public GetQualificationTypeResult getQualificationType(GetQualificationTypeRequest request) {request = beforeClientExecution(request);return executeGetQualificationType(request);}

[Assistant] public virtual GetQualificationTypeResponse GetQualificationType(GetQualificationTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetQualificationTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = GetQualificationTypeResponseUnmarshaller.Instance;return Invoke<GetQualificationTypeResponse>(request, options);}


public ThreeWayMerger newMerger(Repository db, boolean inCore) {return new ResolveMerger(db, inCore);}

public override Merger NewMerger(Repository db, bool inCore){return new ResolveMerger(db, inCore);}

[User] public ThreeWayMerger newMerger(Repository db, boolean inCore) {return new ResolveMerger(db, inCore);}

[Assistant] public override Merger NewMerger(Repository db, bool inCore){return new ResolveMerger(db, inCore);}


public String getNameText(int definedNameIndex) {return _externalNameRecords[definedNameIndex].getText();}

public String GetNameText(int definedNameIndex){return _externalNameRecords[definedNameIndex].Text;}

[User] public String getNameText(int definedNameIndex) {return _externalNameRecords[definedNameIndex].getText();}

[Assistant] public String GetNameText(int definedNameIndex){return _externalNameRecords[definedNameIndex].Text;}


public PlotWalk(Repository repo) {super(repo);super.sort(RevSort.TOPO, true);additionalRefMap = new HashMap<>();repository = repo;}

public PlotWalk(Repository repo) : base(repo){base.Sort(RevSort.TOPO, true);reverseRefMap = repo.GetAllRefsByPeeledObjectId();}

[User] public PlotWalk(Repository repo) {super(repo);super.sort(RevSort.TOPO, true);additionalRefMap = new HashMap<>();repository = repo;}

[Assistant] public PlotWalk(Repository repo) : base(repo){base.Sort(RevSort.TOPO, true);reverseRefMap = repo.GetAllRefsByPeeledObjectId();}


public SubscribeToDatasetResult subscribeToDataset(SubscribeToDatasetRequest request) {request = beforeClientExecution(request);return executeSubscribeToDataset(request);}

public virtual SubscribeToDatasetResponse SubscribeToDataset(SubscribeToDatasetRequest request){var options = new InvokeOptions();options.RequestMarshaller = SubscribeToDatasetRequestMarshaller.Instance;options.ResponseUnmarshaller = SubscribeToDatasetResponseUnmarshaller.Instance;return Invoke<SubscribeToDatasetResponse>(request, options);}

[User] public SubscribeToDatasetResult subscribeToDataset(SubscribeToDatasetRequest request) {request = beforeClientExecution(request);return executeSubscribeToDataset(request);}

[Assistant] public virtual SubscribeToDatasetResponse SubscribeToDataset(SubscribeToDatasetRequest request){var options = new InvokeOptions();options.RequestMarshaller = SubscribeToDatasetRequestMarshaller.Instance;options.ResponseUnmarshaller = SubscribeToDatasetResponseUnmarshaller.Instance;return Invoke<SubscribeToDatasetResponse>(request, options);}


public StringBuilder append(char[] str, int offset, int len) {append0(str, offset, len);return this;}

public java.lang.StringBuilder append(char[] str, int offset, int len){append0(str, offset, len);return this;}

[User] public StringBuilder append(char[] str, int offset, int len) {append0(str, offset, len);return this;}

[Assistant] public java.lang.StringBuilder append(char[] str, int offset, int len){append0(str, offset, len);return this;}


public synchronized int indexOf(String subString, int start) {return super.indexOf(subString, start);}

public override int indexOf(string subString, int start){lock (this){return base.indexOf(subString, start);}}

[User] public synchronized int indexOf(String subString, int start) {return super.indexOf(subString, start);}

[Assistant] public override int indexOf(string subString, int start){lock (this){return base.indexOf(subString, start);}}


public List<E> subList(int from, int to) {Object[] snapshot = elements;if (from < 0 || from > to || to > snapshot.length) {throw new IndexOutOfBoundsException("from=" + from + ", to=" + to +", list size=" + snapshot.length);}return new CowSubList(snapshot, from, to);}

public virtual java.util.List<E> subList(int from, int to){object[] snapshot = elements;if (from < 0 || from > to || to > snapshot.Length){throw new System.IndexOutOfRangeException("from=" + from + ", to=" + to + ", list size="+ snapshot.Length);}return new java.util.concurrent.CopyOnWriteArrayList<E>.CowSubList(this, snapshot, from, to);}

[User] public List<E> subList(int from, int to) {Object[] snapshot = elements;if (from < 0 || from > to || to > snapshot.length) {throw new IndexOutOfBoundsException("from=" + from + ", to=" + to +", list size=" + snapshot.length);}return new CowSubList(snapshot, from, to);}

[Assistant] public virtual java.util.List<E> subList(int from, int to){object[] snapshot = elements;if (from < 0 || from > to || to > snapshot.Length){throw new System.IndexOutOfRangeException("from=" + from + ", to=" + to + ", list size="+ snapshot.Length);}return new java.util.concurrent.CopyOnWriteArrayList<E>.CowSubList(this, snapshot, from, to);}


public Severity getSeverity() {return severity;}

public virtual FormatError.Severity GetSeverity(){return severity;}

[User] public Severity getSeverity() {return severity;}

[Assistant] public virtual FormatError.Severity GetSeverity(){return severity;}


public DescribeBundleTasksResult describeBundleTasks() {return describeBundleTasks(new DescribeBundleTasksRequest());}

public virtual DescribeBundleTasksResponse DescribeBundleTasks(){return DescribeBundleTasks(new DescribeBundleTasksRequest());}

[User] public DescribeBundleTasksResult describeBundleTasks() {return describeBundleTasks(new DescribeBundleTasksRequest());}

[Assistant] public virtual DescribeBundleTasksResponse DescribeBundleTasks(){return DescribeBundleTasks(new DescribeBundleTasksRequest());}


public BooleanQuery build() {return new BooleanQuery(minimumNumberShouldMatch, clauses.toArray(new BooleanClause[0]));}

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

[User] public BooleanQuery build() {return new BooleanQuery(minimumNumberShouldMatch, clauses.toArray(new BooleanClause[0]));}

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


public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[HIDEOBJ]\n");buffer.append("    .hideobj         = ").append(Integer.toHexString(getHideObj())).append("\n");buffer.append("[/HIDEOBJ]\n");return buffer.toString();}

public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[HIDEOBJ]\n");buffer.Append("    .hideobj         = ").Append(StringUtil.ToHexString(GetHideObj())).Append("\n");buffer.Append("[/HIDEOBJ]\n");return buffer.ToString();}

[User] public String toString(){StringBuilder buffer = new StringBuilder();buffer.append("[HIDEOBJ]\n");buffer.append("    .hideobj         = ").append(Integer.toHexString(getHideObj())).append("\n");buffer.append("[/HIDEOBJ]\n");return buffer.toString();}

[Assistant] public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[HIDEOBJ]\n");buffer.Append("    .hideobj         = ").Append(StringUtil.ToHexString(GetHideObj())).Append("\n");buffer.Append("[/HIDEOBJ]\n");return buffer.ToString();}


public UseSelFSRecord(boolean b) {this(0);_options = useNaturalLanguageFormulasFlag.setBoolean(_options, b);}

public UseSelFSRecord(int options){_options = options;}

[User] public UseSelFSRecord(boolean b) {this(0);_options = useNaturalLanguageFormulasFlag.setBoolean(_options, b);}

[Assistant] public UseSelFSRecord(int options){_options = options;}


public boolean equals( Object o ) {return o instanceof RomanianStemmer;}

public override bool Equals(object o){return o is RomanianStemmer;}

[User] public boolean equals( Object o ) {return o instanceof RomanianStemmer;}

[Assistant] public override bool Equals(object o){return o is RomanianStemmer;}


public AbortMultipartUploadResult abortMultipartUpload(AbortMultipartUploadRequest request) {request = beforeClientExecution(request);return executeAbortMultipartUpload(request);}

public virtual AbortMultipartUploadResponse AbortMultipartUpload(AbortMultipartUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = AbortMultipartUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = AbortMultipartUploadResponseUnmarshaller.Instance;return Invoke<AbortMultipartUploadResponse>(request, options);}

[User] public AbortMultipartUploadResult abortMultipartUpload(AbortMultipartUploadRequest request) {request = beforeClientExecution(request);return executeAbortMultipartUpload(request);}

[Assistant] public virtual AbortMultipartUploadResponse AbortMultipartUpload(AbortMultipartUploadRequest request){var options = new InvokeOptions();options.RequestMarshaller = AbortMultipartUploadRequestMarshaller.Instance;options.ResponseUnmarshaller = AbortMultipartUploadResponseUnmarshaller.Instance;return Invoke<AbortMultipartUploadResponse>(request, options);}


public void reportMatch(Parser recognizer) {endErrorCondition(recognizer);}

public virtual void ReportMatch(Parser recognizer){EndErrorCondition(recognizer);}

[User] public void reportMatch(Parser recognizer) {endErrorCondition(recognizer);}

[Assistant] public virtual void ReportMatch(Parser recognizer){EndErrorCondition(recognizer);}


public ModifyVpnConnectionResult modifyVpnConnection(ModifyVpnConnectionRequest request) {request = beforeClientExecution(request);return executeModifyVpnConnection(request);}

public virtual ModifyVpnConnectionResponse ModifyVpnConnection(ModifyVpnConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyVpnConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyVpnConnectionResponseUnmarshaller.Instance;return Invoke<ModifyVpnConnectionResponse>(request, options);}

[User] public ModifyVpnConnectionResult modifyVpnConnection(ModifyVpnConnectionRequest request) {request = beforeClientExecution(request);return executeModifyVpnConnection(request);}

[Assistant] public virtual ModifyVpnConnectionResponse ModifyVpnConnection(ModifyVpnConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyVpnConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyVpnConnectionResponseUnmarshaller.Instance;return Invoke<ModifyVpnConnectionResponse>(request, options);}


public GetSendStatisticsResult getSendStatistics() {return getSendStatistics(new GetSendStatisticsRequest());}

public virtual GetSendStatisticsResponse GetSendStatistics(){return GetSendStatistics(new GetSendStatisticsRequest());}

[User] public GetSendStatisticsResult getSendStatistics() {return getSendStatistics(new GetSendStatisticsRequest());}

[Assistant] public virtual GetSendStatisticsResponse GetSendStatistics(){return GetSendStatistics(new GetSendStatisticsRequest());}


public CreateVoiceConnectorGroupResult createVoiceConnectorGroup(CreateVoiceConnectorGroupRequest request) {request = beforeClientExecution(request);return executeCreateVoiceConnectorGroup(request);}

public virtual CreateVoiceConnectorGroupResponse CreateVoiceConnectorGroup(CreateVoiceConnectorGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVoiceConnectorGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVoiceConnectorGroupResponseUnmarshaller.Instance;return Invoke<CreateVoiceConnectorGroupResponse>(request, options);}

[User] public CreateVoiceConnectorGroupResult createVoiceConnectorGroup(CreateVoiceConnectorGroupRequest request) {request = beforeClientExecution(request);return executeCreateVoiceConnectorGroup(request);}

[Assistant] public virtual CreateVoiceConnectorGroupResponse CreateVoiceConnectorGroup(CreateVoiceConnectorGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVoiceConnectorGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVoiceConnectorGroupResponseUnmarshaller.Instance;return Invoke<CreateVoiceConnectorGroupResponse>(request, options);}


public InitiateJobRequest(String vaultName, JobParameters jobParameters) {setVaultName(vaultName);setJobParameters(jobParameters);}

public InitiateJobRequest(string vaultName, JobParameters jobParameters){_vaultName = vaultName;_jobParameters = jobParameters;}

[User] public InitiateJobRequest(String vaultName, JobParameters jobParameters) {setVaultName(vaultName);setJobParameters(jobParameters);}

[Assistant] public InitiateJobRequest(string vaultName, JobParameters jobParameters){_vaultName = vaultName;_jobParameters = jobParameters;}


public MatchResult toMatchResult() {ensureMatch();return new MatchResultImpl(input, matchOffsets);}

public java.util.regex.MatchResult toMatchResult(){ensureMatch();return new java.util.regex.MatchResultImpl(input, matchOffsets);}

[User] public MatchResult toMatchResult() {ensureMatch();return new MatchResultImpl(input, matchOffsets);}

[Assistant] public java.util.regex.MatchResult toMatchResult(){ensureMatch();return new java.util.regex.MatchResultImpl(input, matchOffsets);}


public static String getInflectedFormTranslation(String s) {return inflFormTranslations.get(s);}

public static string GetInflectedFormTranslation(string s){string result;inflFormTranslations.TryGetValue(s, out result);return result;}

[User] public static String getInflectedFormTranslation(String s) {return inflFormTranslations.get(s);}

[Assistant] public static string GetInflectedFormTranslation(string s){string result;inflFormTranslations.TryGetValue(s, out result);return result;}


public static ErrPtg valueOf(int code) {switch(FormulaError.forInt(code)) {case DIV0: return DIV_ZERO;case NA: return N_A;case NAME: return NAME_INVALID;case NULL: return NULL_INTERSECTION;case NUM: return NUM_ERROR;case REF: return REF_INVALID;case VALUE: return VALUE_INVALID;default:throw new RuntimeException("Unexpected error code (" + code + ")");}}

public static ErrPtg ValueOf(int code){switch (code){case HSSFErrorConstants.ERROR_DIV_0: return DIV_ZERO;case HSSFErrorConstants.ERROR_NA: return N_A;case HSSFErrorConstants.ERROR_NAME: return NAME_INVALID;case HSSFErrorConstants.ERROR_NULL: return NULL_INTERSECTION;case HSSFErrorConstants.ERROR_NUM: return NUM_ERROR;case HSSFErrorConstants.ERROR_REF: return REF_INVALID;case HSSFErrorConstants.ERROR_VALUE: return VALUE_INVALID;}throw new InvalidOperationException("Unexpected error code (" + code + ")");}

[User] public static ErrPtg valueOf(int code) {switch(FormulaError.forInt(code)) {case DIV0: return DIV_ZERO;case NA: return N_A;case NAME: return NAME_INVALID;case NULL: return NULL_INTERSECTION;case NUM: return NUM_ERROR;case REF: return REF_INVALID;case VALUE: return VALUE_INVALID;default:throw new RuntimeException("Unexpected error code (" + code + ")");}}

[Assistant] public static ErrPtg ValueOf(int code){switch (code){case HSSFErrorConstants.ERROR_DIV_0: return DIV_ZERO;case HSSFErrorConstants.ERROR_NA: return N_A;case HSSFErrorConstants.ERROR_NAME: return NAME_INVALID;case HSSFErrorConstants.ERROR_NULL: return NULL_INTERSECTION;case HSSFErrorConstants.ERROR_NUM: return NUM_ERROR;case HSSFErrorConstants.ERROR_REF: return REF_INVALID;case HSSFErrorConstants.ERROR_VALUE: return VALUE_INVALID;}throw new InvalidOperationException("Unexpected error code (" + code + ")");}


public GetBasePathMappingResult getBasePathMapping(GetBasePathMappingRequest request) {request = beforeClientExecution(request);return executeGetBasePathMapping(request);}

public virtual GetBasePathMappingResponse GetBasePathMapping(GetBasePathMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBasePathMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBasePathMappingResponseUnmarshaller.Instance;return Invoke<GetBasePathMappingResponse>(request, options);}

[User] public GetBasePathMappingResult getBasePathMapping(GetBasePathMappingRequest request) {request = beforeClientExecution(request);return executeGetBasePathMapping(request);}

[Assistant] public virtual GetBasePathMappingResponse GetBasePathMapping(GetBasePathMappingRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBasePathMappingRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBasePathMappingResponseUnmarshaller.Instance;return Invoke<GetBasePathMappingResponse>(request, options);}


public void fromObjectId(AnyObjectId src) {this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}

public virtual void FromObjectId(AnyObjectId src){this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}

[User] public void fromObjectId(AnyObjectId src) {this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}

[Assistant] public virtual void FromObjectId(AnyObjectId src){this.w1 = src.w1;this.w2 = src.w2;this.w3 = src.w3;this.w4 = src.w4;this.w5 = src.w5;}


public static List<? extends Tree> getAncestors(Tree t) {if ( t.getParent()==null ) return Collections.emptyList();List<Tree> ancestors = new ArrayList<Tree>();t = t.getParent();while ( t!=null ) {ancestors.add(0, t); t = t.getParent();}return ancestors;}

public static IList<ITree> GetAncestors(ITree t){if (t.Parent == null){return Collections.EmptyList<ITree>();}IList<ITree> ancestors = new List<ITree>();t = t.Parent;while (t != null){ancestors.Insert(0, t);t = t.Parent;}return ancestors;}

[User] public static List<? extends Tree> getAncestors(Tree t) {if ( t.getParent()==null ) return Collections.emptyList();List<Tree> ancestors = new ArrayList<Tree>();t = t.getParent();while ( t!=null ) {ancestors.add(0, t); t = t.getParent();}return ancestors;}

[Assistant] public static IList<ITree> GetAncestors(ITree t){if (t.Parent == null){return Collections.EmptyList<ITree>();}IList<ITree> ancestors = new List<ITree>();t = t.Parent;while (t != null){ancestors.Insert(0, t);t = t.Parent;}return ancestors;}


public GetUsagePlanResult getUsagePlan(GetUsagePlanRequest request) {request = beforeClientExecution(request);return executeGetUsagePlan(request);}

public virtual GetUsagePlanResponse GetUsagePlan(GetUsagePlanRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetUsagePlanRequestMarshaller.Instance;options.ResponseUnmarshaller = GetUsagePlanResponseUnmarshaller.Instance;return Invoke<GetUsagePlanResponse>(request, options);}

[User] public GetUsagePlanResult getUsagePlan(GetUsagePlanRequest request) {request = beforeClientExecution(request);return executeGetUsagePlan(request);}

[Assistant] public virtual GetUsagePlanResponse GetUsagePlan(GetUsagePlanRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetUsagePlanRequestMarshaller.Instance;options.ResponseUnmarshaller = GetUsagePlanResponseUnmarshaller.Instance;return Invoke<GetUsagePlanResponse>(request, options);}


public UpdateLoadBalancerAttributeResult updateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request) {request = beforeClientExecution(request);return executeUpdateLoadBalancerAttribute(request);}

public virtual UpdateLoadBalancerAttributeResponse UpdateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateLoadBalancerAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateLoadBalancerAttributeResponseUnmarshaller.Instance;return Invoke<UpdateLoadBalancerAttributeResponse>(request, options);}

[User] public UpdateLoadBalancerAttributeResult updateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request) {request = beforeClientExecution(request);return executeUpdateLoadBalancerAttribute(request);}

[Assistant] public virtual UpdateLoadBalancerAttributeResponse UpdateLoadBalancerAttribute(UpdateLoadBalancerAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateLoadBalancerAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateLoadBalancerAttributeResponseUnmarshaller.Instance;return Invoke<UpdateLoadBalancerAttributeResponse>(request, options);}


public void addResult(int n, boolean isRelevant, long docNameExtractTime) {if (Math.abs(numPoints+1 - n) > 1E-6) {throw new IllegalArgumentException("point "+n+" illegal after "+numPoints+" points!");}if (isRelevant) {numGoodPoints+=1;recallPoints.add(new RecallPoint(n,numGoodPoints));if (recallPoints.size()==1 && n<=5) { mrr =  1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant) {pReleventSum += p;}if (n<pAt.length) {pAt[n] = p;}recall = maxGoodPoints<=0 ? p : numGoodPoints/maxGoodPoints;docNamesExtractTime += docNameExtractTime;}

public virtual void AddResult(int n, bool isRelevant, long docNameExtractTime){if (Math.Abs(numPoints + 1 - n) > 1E-6){throw new ArgumentException("point " + n + " illegal after " + numPoints + " points!");}if (isRelevant){numGoodPoints += 1;recallPoints.Add(new RecallPoint(n, numGoodPoints));if (recallPoints.Count == 1 && n <= 5){ mrr = 1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant){pReleventSum += p;}if (n < pAt.Length){pAt[n] = p;}recall = maxGoodPoints <= 0 ? p : numGoodPoints / maxGoodPoints;docNamesExtractTime += docNameExtractTime;}

[User] public void addResult(int n, boolean isRelevant, long docNameExtractTime) {if (Math.abs(numPoints+1 - n) > 1E-6) {throw new IllegalArgumentException("point "+n+" illegal after "+numPoints+" points!");}if (isRelevant) {numGoodPoints+=1;recallPoints.add(new RecallPoint(n,numGoodPoints));if (recallPoints.size()==1 && n<=5) { mrr =  1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant) {pReleventSum += p;}if (n<pAt.length) {pAt[n] = p;}recall = maxGoodPoints<=0 ? p : numGoodPoints/maxGoodPoints;docNamesExtractTime += docNameExtractTime;}

[Assistant] public virtual void AddResult(int n, bool isRelevant, long docNameExtractTime){if (Math.Abs(numPoints + 1 - n) > 1E-6){throw new ArgumentException("point " + n + " illegal after " + numPoints + " points!");}if (isRelevant){numGoodPoints += 1;recallPoints.Add(new RecallPoint(n, numGoodPoints));if (recallPoints.Count == 1 && n <= 5){ mrr = 1.0 / n;}}numPoints = n;double p = numGoodPoints / numPoints;if (isRelevant){pReleventSum += p;}if (n < pAt.Length){pAt[n] = p;}recall = maxGoodPoints <= 0 ? p : numGoodPoints / maxGoodPoints;docNamesExtractTime += docNameExtractTime;}


public UpdateExperimentResult updateExperiment(UpdateExperimentRequest request) {request = beforeClientExecution(request);return executeUpdateExperiment(request);}

public virtual UpdateExperimentResponse UpdateExperiment(UpdateExperimentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance;return Invoke<UpdateExperimentResponse>(request, options);}

[User] public UpdateExperimentResult updateExperiment(UpdateExperimentRequest request) {request = beforeClientExecution(request);return executeUpdateExperiment(request);}

[Assistant] public virtual UpdateExperimentResponse UpdateExperiment(UpdateExperimentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateExperimentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateExperimentResponseUnmarshaller.Instance;return Invoke<UpdateExperimentResponse>(request, options);}


public String toString() {return "(" + a.toString() + " AND " + b.toString() + ")";}

public override string ToString(){return "(" + a.ToString() + " OR " + b.ToString() + ")";}

[User] public String toString() {return "(" + a.toString() + " AND " + b.toString() + ")";}

[Assistant] public override string ToString(){return "(" + a.ToString() + " OR " + b.ToString() + ")";}


public String getAccessKeyId() {return accessKeyId;}

public string GetAccessKeyId(){return accessKeyId;}

[User] public String getAccessKeyId() {return accessKeyId;}

[Assistant] public string GetAccessKeyId(){return accessKeyId;}


public GetBulkPublishDetailsResult getBulkPublishDetails(GetBulkPublishDetailsRequest request) {request = beforeClientExecution(request);return executeGetBulkPublishDetails(request);}

public virtual GetBulkPublishDetailsResponse GetBulkPublishDetails(GetBulkPublishDetailsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBulkPublishDetailsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBulkPublishDetailsResponseUnmarshaller.Instance;return Invoke<GetBulkPublishDetailsResponse>(request, options);}

[User] public GetBulkPublishDetailsResult getBulkPublishDetails(GetBulkPublishDetailsRequest request) {request = beforeClientExecution(request);return executeGetBulkPublishDetails(request);}

[Assistant] public virtual GetBulkPublishDetailsResponse GetBulkPublishDetails(GetBulkPublishDetailsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBulkPublishDetailsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBulkPublishDetailsResponseUnmarshaller.Instance;return Invoke<GetBulkPublishDetailsResponse>(request, options);}


public static byte[] grow(byte[] array) {return grow(array, 1 + array.length);}

public static float[] Grow(float[] array){return Grow(array, 1 + array.Length);}

[User] public static byte[] grow(byte[] array) {return grow(array, 1 + array.length);}

[Assistant] public static float[] Grow(float[] array){return Grow(array, 1 + array.Length);}


public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2) {double result;try {result = evaluate(evalArg(arg0, srcRowIndex, srcColumnIndex), evalArg(arg1, srcRowIndex, srcColumnIndex), evalArg(arg2, srcRowIndex, srcColumnIndex));} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2){double result;try{result = Evaluate(EvalArg(arg0, srcRowIndex, srcColumnIndex), EvalArg(arg1, srcRowIndex, srcColumnIndex), EvalArg(arg2, srcRowIndex, srcColumnIndex));}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}

[User] public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2) {double result;try {result = evaluate(evalArg(arg0, srcRowIndex, srcColumnIndex), evalArg(arg1, srcRowIndex, srcColumnIndex), evalArg(arg2, srcRowIndex, srcColumnIndex));} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

[Assistant] public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0, ValueEval arg1,ValueEval arg2){double result;try{result = Evaluate(EvalArg(arg0, srcRowIndex, srcColumnIndex), EvalArg(arg1, srcRowIndex, srcColumnIndex), EvalArg(arg2, srcRowIndex, srcColumnIndex));}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}


public static final int hash32(final byte[] data, int offset, int len) {return MurmurHash2.hash(data, 0x9747b28c, offset, len);}

public static int Hash32(byte[] data, int offset, int len){return Hash(data, unchecked((int)0x9747b28c), offset, len);}

[User] public static final int hash32(final byte[] data, int offset, int len) {return MurmurHash2.hash(data, 0x9747b28c, offset, len);}

[Assistant] public static int Hash32(byte[] data, int offset, int len){return Hash(data, unchecked((int)0x9747b28c), offset, len);}


public static Formula create(Ptg[] ptgs) {if (ptgs == null || ptgs.length < 1) {return EMPTY;}int totalSize = Ptg.getEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.serializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.getEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}

public static Formula Create(Ptg[] ptgs){if (ptgs == null || ptgs.Length < 1){return EMPTY;}int totalSize = Ptg.GetEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.SerializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.GetEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}

[User] public static Formula create(Ptg[] ptgs) {if (ptgs == null || ptgs.length < 1) {return EMPTY;}int totalSize = Ptg.getEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.serializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.getEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}

[Assistant] public static Formula Create(Ptg[] ptgs){if (ptgs == null || ptgs.Length < 1){return EMPTY;}int totalSize = Ptg.GetEncodedSize(ptgs);byte[] encodedData = new byte[totalSize];Ptg.SerializePtgs(ptgs, encodedData, 0);int encodedTokenLen = Ptg.GetEncodedSizeWithoutArrayData(ptgs);return new Formula(encodedData, encodedTokenLen);}


public String toString(String field){return null;}

public override string ToString(string field){return null;}

[User] public String toString(String field){return null;}

[Assistant] public override string ToString(string field){return null;}


public static int deleteN(char s[], int pos, int len, int nChars) {assert pos + nChars <= len;if (pos + nChars < len) { System.arraycopy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}

public static int DeleteN(char[] s, int pos, int len, int nChars){Debug.Assert(pos + nChars <= len);if (pos + nChars < len) {Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}

[User] public static int deleteN(char s[], int pos, int len, int nChars) {assert pos + nChars <= len;if (pos + nChars < len) { System.arraycopy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}

[Assistant] public static int DeleteN(char[] s, int pos, int len, int nChars){Debug.Assert(pos + nChars <= len);if (pos + nChars < len) {Array.Copy(s, pos + nChars, s, pos, len - pos - nChars);}return len - nChars;}


public ThreadSafeProgressMonitor(ProgressMonitor pm) {this.pm = pm;this.lock = new ReentrantLock();this.mainThread = Thread.currentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = new Semaphore(0);}

public ThreadSafeProgressMonitor(ProgressMonitor pm){this.pm = pm;this.Lock = new ReentrantLock();this.mainThread = Sharpen.Thread.CurrentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = Sharpen.Extensions.CreateSemaphore(0);}

[User] public ThreadSafeProgressMonitor(ProgressMonitor pm) {this.pm = pm;this.lock = new ReentrantLock();this.mainThread = Thread.currentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = new Semaphore(0);}

[Assistant] public ThreadSafeProgressMonitor(ProgressMonitor pm){this.pm = pm;this.Lock = new ReentrantLock();this.mainThread = Sharpen.Thread.CurrentThread();this.workers = new AtomicInteger(0);this.pendingUpdates = new AtomicInteger(0);this.process = Sharpen.Extensions.CreateSemaphore(0);}


public SendMessageBatchRequestEntry(String id, String messageBody) {setId(id);setMessageBody(messageBody);}

public SendMessageBatchRequestEntry(string id, string messageBody){_id = id;_messageBody = messageBody;}

[User] public SendMessageBatchRequestEntry(String id, String messageBody) {setId(id);setMessageBody(messageBody);}

[Assistant] public SendMessageBatchRequestEntry(string id, string messageBody){_id = id;_messageBody = messageBody;}


public DescribeAddressResult describeAddress(DescribeAddressRequest request) {request = beforeClientExecution(request);return executeDescribeAddress(request);}

public virtual DescribeAddressResponse DescribeAddress(DescribeAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAddressResponseUnmarshaller.Instance;return Invoke<DescribeAddressResponse>(request, options);}

[User] public DescribeAddressResult describeAddress(DescribeAddressRequest request) {request = beforeClientExecution(request);return executeDescribeAddress(request);}

[Assistant] public virtual DescribeAddressResponse DescribeAddress(DescribeAddressRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeAddressRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeAddressResponseUnmarshaller.Instance;return Invoke<DescribeAddressResponse>(request, options);}


public GetEventRequest() {super("CloudPhoto", "2017-07-11", "GetEvent", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

public GetEventRequest(): base("CloudPhoto", "2017-07-11", "GetEvent", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}

[User] public GetEventRequest() {super("CloudPhoto", "2017-07-11", "GetEvent", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

[Assistant] public GetEventRequest(): base("CloudPhoto", "2017-07-11", "GetEvent", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}


public DescribeRuleResult describeRule(DescribeRuleRequest request) {request = beforeClientExecution(request);return executeDescribeRule(request);}

public virtual DescribeRuleResponse DescribeRule(DescribeRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRuleResponseUnmarshaller.Instance;return Invoke<DescribeRuleResponse>(request, options);}

[User] public DescribeRuleResult describeRule(DescribeRuleRequest request) {request = beforeClientExecution(request);return executeDescribeRule(request);}

[Assistant] public virtual DescribeRuleResponse DescribeRule(DescribeRuleRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeRuleRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeRuleResponseUnmarshaller.Instance;return Invoke<DescribeRuleResponse>(request, options);}


public final RevObject getObject() {return object;}

public RevObject GetObject(){return @object;}

[User] public final RevObject getObject() {return object;}

[Assistant] public RevObject GetObject(){return @object;}


public JapaneseIterationMarkCharFilterFactory(Map<String,String> args) {super(args);normalizeKanji = getBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = getBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public JapaneseIterationMarkCharFilterFactory(IDictionary<string, string> args): base(args){normalizeKanji = GetBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = GetBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (args.Count > 0){throw new ArgumentException("Unknown parameters: " + args);}}

[User] public JapaneseIterationMarkCharFilterFactory(Map<String,String> args) {super(args);normalizeKanji = getBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = getBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

[Assistant] public JapaneseIterationMarkCharFilterFactory(IDictionary<string, string> args): base(args){normalizeKanji = GetBoolean(args, NORMALIZE_KANJI_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANJI_DEFAULT);normalizeKana = GetBoolean(args, NORMALIZE_KANA_PARAM, JapaneseIterationMarkCharFilter.NORMALIZE_KANA_DEFAULT);if (args.Count > 0){throw new ArgumentException("Unknown parameters: " + args);}}


public char previous() {if (--index < start) {index = start;return DONE;} else {return current();}}

public override char Previous(){if (--index < start){index = start;return Done;}else{return Current;}}

[User] public char previous() {if (--index < start) {index = start;return DONE;} else {return current();}}

[Assistant] public override char Previous(){if (--index < start){index = start;return Done;}else{return Current;}}


public LoggingConfig(String bucket, String prefix) {setBucket(bucket);setPrefix(prefix);}

public LoggingConfig(string bucket, string prefix){_bucket = bucket;_prefix = prefix;}

[User] public LoggingConfig(String bucket, String prefix) {setBucket(bucket);setPrefix(prefix);}

[Assistant] public LoggingConfig(string bucket, string prefix){_bucket = bucket;_prefix = prefix;}


public static String createSafeSheetName(final String nameProposal) {return createSafeSheetName(nameProposal, ' ');}

public static String CreateSafeSheetName(String nameProposal){return CreateSafeSheetName(nameProposal, ' ');}

[User] public static String createSafeSheetName(final String nameProposal) {return createSafeSheetName(nameProposal, ' ');}

[Assistant] public static String CreateSafeSheetName(String nameProposal){return CreateSafeSheetName(nameProposal, ' ');}


public PutMetricAlarmResult putMetricAlarm(PutMetricAlarmRequest request) {request = beforeClientExecution(request);return executePutMetricAlarm(request);}

public virtual PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutMetricAlarmRequestMarshaller.Instance;options.ResponseUnmarshaller = PutMetricAlarmResponseUnmarshaller.Instance;return Invoke<PutMetricAlarmResponse>(request, options);}

[User] public PutMetricAlarmResult putMetricAlarm(PutMetricAlarmRequest request) {request = beforeClientExecution(request);return executePutMetricAlarm(request);}

[Assistant] public virtual PutMetricAlarmResponse PutMetricAlarm(PutMetricAlarmRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutMetricAlarmRequestMarshaller.Instance;options.ResponseUnmarshaller = PutMetricAlarmResponseUnmarshaller.Instance;return Invoke<PutMetricAlarmResponse>(request, options);}


public CreateExclusionsPreviewResult createExclusionsPreview(CreateExclusionsPreviewRequest request) {request = beforeClientExecution(request);return executeCreateExclusionsPreview(request);}

public virtual CreateExclusionsPreviewResponse CreateExclusionsPreview(CreateExclusionsPreviewRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateExclusionsPreviewRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateExclusionsPreviewResponseUnmarshaller.Instance;return Invoke<CreateExclusionsPreviewResponse>(request, options);}

[User] public CreateExclusionsPreviewResult createExclusionsPreview(CreateExclusionsPreviewRequest request) {request = beforeClientExecution(request);return executeCreateExclusionsPreview(request);}

[Assistant] public virtual CreateExclusionsPreviewResponse CreateExclusionsPreview(CreateExclusionsPreviewRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateExclusionsPreviewRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateExclusionsPreviewResponseUnmarshaller.Instance;return Invoke<CreateExclusionsPreviewResponse>(request, options);}


public OutputStream getRawStream() {return buf;}

public virtual OutputStream GetRawStream(){return buf;}

[User] public OutputStream getRawStream() {return buf;}

[Assistant] public virtual OutputStream GetRawStream(){return buf;}


public int getThreads() {return threads;}

public virtual int GetThreads(){return threads;}

[User] public int getThreads() {return threads;}

[Assistant] public virtual int GetThreads(){return threads;}


public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final int byte0 = blocks[blocksOffset++] & 0xFF;final int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | (byte1 >>> 2);final int byte2 = blocks[blocksOffset++] & 0xFF;final int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | (byte3 >>> 4);final int byte4 = blocks[blocksOffset++] & 0xFF;final int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | (byte5 >>> 6);final int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}

public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | ((int)((uint)byte1 >> 2));int byte2 = blocks[blocksOffset++] & 0xFF;int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | ((int)((uint)byte3 >> 4));int byte4 = blocks[blocksOffset++] & 0xFF;int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | ((int)((uint)byte5 >> 6));int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}

[User] public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final int byte0 = blocks[blocksOffset++] & 0xFF;final int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | (byte1 >>> 2);final int byte2 = blocks[blocksOffset++] & 0xFF;final int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | (byte3 >>> 4);final int byte4 = blocks[blocksOffset++] & 0xFF;final int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | (byte5 >>> 6);final int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}

[Assistant] public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 6) | ((int)((uint)byte1 >> 2));int byte2 = blocks[blocksOffset++] & 0xFF;int byte3 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 3) << 12) | (byte2 << 4) | ((int)((uint)byte3 >> 4));int byte4 = blocks[blocksOffset++] & 0xFF;int byte5 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte3 & 15) << 10) | (byte4 << 2) | ((int)((uint)byte5 >> 6));int byte6 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte5 & 63) << 8) | byte6;}}


public boolean eof() {assert upto + bufferOffset <= endIndex;return upto + bufferOffset == endIndex;}

public bool Eof(){Debug.Assert(upto + BufferOffset <= EndIndex);return upto + BufferOffset == EndIndex;}

[User] public boolean eof() {assert upto + bufferOffset <= endIndex;return upto + bufferOffset == endIndex;}

[Assistant] public bool Eof(){Debug.Assert(upto + BufferOffset <= EndIndex);return upto + BufferOffset == EndIndex;}


public ClientException(String message) {super(message);this.setErrorType(ErrorType.Client);}

public ClientException(string message) : base(message){ErrorMessage = message;}

[User] public ClientException(String message) {super(message);this.setErrorType(ErrorType.Client);}

[Assistant] public ClientException(string message) : base(message){ErrorMessage = message;}


public static NumberRecord[] convertRKRecords(MulRKRecord mrk) {NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];for (int k = 0; k < mrk.getNumColumns(); k++) {NumberRecord nr = new NumberRecord();nr.setColumn((short) (k + mrk.getFirstColumn()));nr.setRow(mrk.getRow());nr.setXFIndex(mrk.getXFAt(k));nr.setValue(mrk.getRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}

public static NumberRecord[] ConvertRKRecords(MulRKRecord mrk){NumberRecord[] mulRecs = new NumberRecord[mrk.NumColumns];for (int k = 0; k < mrk.NumColumns; k++){NumberRecord nr = new NumberRecord();nr.Column = ((short)(k + mrk.FirstColumn));nr.Row = (mrk.Row);nr.XFIndex = (mrk.GetXFAt(k));nr.Value = (mrk.GetRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}

[User] public static NumberRecord[] convertRKRecords(MulRKRecord mrk) {NumberRecord[] mulRecs = new NumberRecord[mrk.getNumColumns()];for (int k = 0; k < mrk.getNumColumns(); k++) {NumberRecord nr = new NumberRecord();nr.setColumn((short) (k + mrk.getFirstColumn()));nr.setRow(mrk.getRow());nr.setXFIndex(mrk.getXFAt(k));nr.setValue(mrk.getRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}

[Assistant] public static NumberRecord[] ConvertRKRecords(MulRKRecord mrk){NumberRecord[] mulRecs = new NumberRecord[mrk.NumColumns];for (int k = 0; k < mrk.NumColumns; k++){NumberRecord nr = new NumberRecord();nr.Column = ((short)(k + mrk.FirstColumn));nr.Row = (mrk.Row);nr.XFIndex = (mrk.GetXFAt(k));nr.Value = (mrk.GetRKNumberAt(k));mulRecs[k] = nr;}return mulRecs;}


public List<ReceiveCommand> getCommands() {return Collections.unmodifiableList(commands);}

public virtual IList<ReceiveCommand> GetCommands(){return Sharpen.Collections.UnmodifiableList(commands);}

[User] public List<ReceiveCommand> getCommands() {return Collections.unmodifiableList(commands);}

[Assistant] public virtual IList<ReceiveCommand> GetCommands(){return Sharpen.Collections.UnmodifiableList(commands);}


public UpdateVoiceConnectorResult updateVoiceConnector(UpdateVoiceConnectorRequest request) {request = beforeClientExecution(request);return executeUpdateVoiceConnector(request);}

public virtual UpdateVoiceConnectorResponse UpdateVoiceConnector(UpdateVoiceConnectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateVoiceConnectorRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateVoiceConnectorResponseUnmarshaller.Instance;return Invoke<UpdateVoiceConnectorResponse>(request, options);}

[User] public UpdateVoiceConnectorResult updateVoiceConnector(UpdateVoiceConnectorRequest request) {request = beforeClientExecution(request);return executeUpdateVoiceConnector(request);}

[Assistant] public virtual UpdateVoiceConnectorResponse UpdateVoiceConnector(UpdateVoiceConnectorRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateVoiceConnectorRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateVoiceConnectorResponseUnmarshaller.Instance;return Invoke<UpdateVoiceConnectorResponse>(request, options);}


public static String getText(int errorCode) {if(FormulaError.isValidCode(errorCode)) {return FormulaError.forInt(errorCode).getString();}return "~non~std~err(" + errorCode + ")~";}

public static String GetText(int errorCode){if (FormulaError.IsValidCode(errorCode)){return FormulaError.ForInt(errorCode).String;}return "~non~std~err(" + errorCode + ")~";}

[User] public static String getText(int errorCode) {if(FormulaError.isValidCode(errorCode)) {return FormulaError.forInt(errorCode).getString();}return "~non~std~err(" + errorCode + ")~";}

[Assistant] public static String GetText(int errorCode){if (FormulaError.IsValidCode(errorCode)){return FormulaError.ForInt(errorCode).String;}return "~non~std~err(" + errorCode + ")~";}


public long nextOrd() {long v = ord;ord = NO_MORE_ORDS;return v;}

public override long NextOrd(){if (set){return NO_MORE_ORDS;}else{set = true;return @in.GetOrd(docID);}}

[User] public long nextOrd() {long v = ord;ord = NO_MORE_ORDS;return v;}

[Assistant] public override long NextOrd(){if (set){return NO_MORE_ORDS;}else{set = true;return @in.GetOrd(docID);}}


public EntityResolver getEntityResolver () {return (theEntityResolver == this) ? null : theEntityResolver;}

public void close (){lock (this.mBlock) {if (this.mParseState != null) {this.mParseState.Dispose ();this.mParseState = null;this.mBlock.decOpenCountLocked ();}}}

[User] public EntityResolver getEntityResolver () {return (theEntityResolver == this) ? null : theEntityResolver;}

[Assistant] public void close (){lock (this.mBlock) {if (this.mParseState != null) {this.mParseState.Dispose ();this.mParseState = null;this.mBlock.decOpenCountLocked ();}}}


public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex) {if (sheetIndex < 0) {throw new IllegalArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}

public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex){if (sheetIndex < 0){throw new ArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}

[User] public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex) {if (sheetIndex < 0) {throw new IllegalArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}

[Assistant] public SheetRefEvaluator(WorkbookEvaluator bookEvaluator, EvaluationTracker tracker, int sheetIndex){if (sheetIndex < 0){throw new ArgumentException("Invalid sheetIndex: " + sheetIndex + ".");}_bookEvaluator = bookEvaluator;_tracker = tracker;_sheetIndex = sheetIndex;}