yijunyu/c-to-rust huggingface dataset:
// Original:
public RebuildWorkspacesResult rebuildWorkspaces(RebuildWorkspacesRequest request) {request = beforeClientExecution(request);return executeRebuildWorkspaces(request);}

// Translation:
public virtual RebuildWorkspacesResponse RebuildWorkspaces(RebuildWorkspacesRequest request){var options = new InvokeOptions();options.RequestMarshaller = RebuildWorkspacesRequestMarshaller.Instance;options.ResponseUnmarshaller = RebuildWorkspacesResponseUnmarshaller.Instance;return Invoke<RebuildWorkspacesResponse>(request, options);}
// Original:
public GetLexiconResult getLexicon(GetLexiconRequest request) {request = beforeClientExecution(request);return executeGetLexicon(request);}

// Translation:
public virtual GetLexiconResponse GetLexicon(GetLexiconRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetLexiconRequestMarshaller.Instance;options.ResponseUnmarshaller = GetLexiconResponseUnmarshaller.Instance;return Invoke<GetLexiconResponse>(request, options);}
// Original:
public UpdateDeploymentStrategyResult updateDeploymentStrategy(UpdateDeploymentStrategyRequest request) {request = beforeClientExecution(request);return executeUpdateDeploymentStrategy(request);}

// Translation:
public virtual UpdateDeploymentStrategyResponse UpdateDeploymentStrategy(UpdateDeploymentStrategyRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDeploymentStrategyRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDeploymentStrategyResponseUnmarshaller.Instance;return Invoke<UpdateDeploymentStrategyResponse>(request, options);}
// Original:
public GetAlgorithmListRequest() {super("industry-brain", "2018-07-12", "GetAlgorithmList");setProtocol(ProtocolType.HTTPS);}

// Translation:
public GetAlgorithmListRequest(): base("industry-brain", "2018-07-12", "GetAlgorithmList"){Protocol = ProtocolType.HTTPS;}
// Original:
public boolean isForceUpdate() {return forceUpdate;}

// Translation:
public virtual bool IsForceUpdate(){return forceUpdate;}
// Original:
public ListGameServersResult listGameServers(ListGameServersRequest request) {request = beforeClientExecution(request);return executeListGameServers(request);}

// Translation:
public virtual ListGameServersResponse ListGameServers(ListGameServersRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListGameServersRequestMarshaller.Instance;options.ResponseUnmarshaller = ListGameServersResponseUnmarshaller.Instance;return Invoke<ListGameServersResponse>(request, options);}
// Original:
public boolean delete(){boolean rval = false;if ((!isRoot()) && isDeleteOK()){rval = _parent.deleteEntry(this);}return rval;}

// Translation:
public bool Delete(){bool rval = false;if ((!IsRoot) && IsDeleteOK){rval = _parent.DeleteEntry(this);}return rval;}
// Original:
public TableRecord(RecordInputStream in) {super(in);field_5_flags        = in.readByte();field_6_res          = in.readByte();field_7_rowInputRow  = in.readShort();field_8_colInputRow  = in.readShort();field_9_rowInputCol  = in.readShort();field_10_colInputCol = in.readShort();}

// Translation:
public TableRecord(RecordInputStream in1): base(in1){field_5_flags = in1.ReadByte();field_6_res = in1.ReadByte();field_7_rowInputRow = in1.ReadShort();field_8_colInputRow = in1.ReadShort();field_9_rowInputCol = in1.ReadShort();field_10_colInputCol = in1.ReadShort();}
// Original:
public AllocateHostsResult allocateHosts(AllocateHostsRequest request) {request = beforeClientExecution(request);return executeAllocateHosts(request);}

// Translation:
public virtual AllocateHostsResponse AllocateHosts(AllocateHostsRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocateHostsRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocateHostsResponseUnmarshaller.Instance;return Invoke<AllocateHostsResponse>(request, options);}
// Original:
public void writeContinue() {_ulrOutput.terminate();_totalPreviousRecordsSize += _ulrOutput.getTotalSize();_ulrOutput = new UnknownLengthRecordOutput(_out, ContinueRecord.sid);}

// Translation:
public void WriteContinue(){_ulrOutput.Terminate();_totalPreviousRecordsSize += _ulrOutput.TotalSize;_ulrOutput = new UnknownLengthRecordOutput(_out, ContinueRecord.sid);}
// Original:
public void unread(byte[] buffer, int offset, int length) throws IOException {if (length > pos) {throw new IOException("Pushback buffer full");}Arrays.checkOffsetAndCount(buffer.length, offset, length);if (buf == null) {throw streamClosed();}System.arraycopy(buffer, offset, buf, pos - length, length);pos = pos - length;}

// Translation:
public virtual void unread(byte[] buffer, int offset, int length){if (length > pos){throw new System.IO.IOException("Pushback buffer full");}java.util.Arrays.checkOffsetAndCount(buffer.Length, offset, length);if (buf == null){throw streamClosed();}System.Array.Copy(buffer, offset, buf, pos - length, length);pos = pos - length;}
// Original:
public boolean containsCell(BookSheetKey key, int rowIndex, int columnIndex) {BlankCellSheetGroup bcsg = _sheetGroupsByBookSheet.get(key);if (bcsg == null) {return false;}return bcsg.containsCell(rowIndex, columnIndex);}

// Translation:
public bool ContainsCell(BookSheetKey key, int rowIndex, int columnIndex){BlankCellSheetGroup bcsg = (BlankCellSheetGroup)_sheetGroupsByBookSheet[key];if (bcsg == null){return false;}return bcsg.ContainsCell(rowIndex, columnIndex);}
// Original:
public DescribeTextTranslationJobResult describeTextTranslationJob(DescribeTextTranslationJobRequest request) {request = beforeClientExecution(request);return executeDescribeTextTranslationJob(request);}

// Translation:
public virtual DescribeTextTranslationJobResponse DescribeTextTranslationJob(DescribeTextTranslationJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTextTranslationJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTextTranslationJobResponseUnmarshaller.Instance;return Invoke<DescribeTextTranslationJobResponse>(request, options);}
// Original:
public int serialize( int offset, byte[] data, EscherSerializationListener listener ){listener.beforeRecordSerialize( offset, getRecordId(), this );if (remainingData == null) {remainingData = new byte[0];}LittleEndian.putShort( data, offset, getOptions() );LittleEndian.putShort( data, offset + 2, getRecordId() );int remainingBytes = remainingData.length + (shortRecord ? 8 : 18);LittleEndian.putInt( data, offset + 4, remainingBytes );LittleEndian.putShort( data, offset + 8, field_1_flag );LittleEndian.putShort( data, offset + 10, field_2_col1 );LittleEndian.putShort( data, offset + 12, field_3_dx1 );LittleEndian.putShort( data, offset + 14, field_4_row1 );if(!shortRecord) {LittleEndian.putShort( data, offset + 16, field_5_dy1 );LittleEndian.putShort( data, offset + 18, field_6_col2 );LittleEndian.putShort( data, offset + 20, field_7_dx2 );LittleEndian.putShort( data, offset + 22, field_8_row2 );LittleEndian.putShort( data, offset + 24, field_9_dy2 );}System.arraycopy( remainingData, 0, data, offset + (shortRecord ? 16 : 26), remainingData.length );int pos = offset + 8 + (shortRecord ? 8 : 18) + remainingData.length;listener.afterRecordSerialize( pos, getRecordId(), pos - offset, this );return pos - offset;}

// Translation:
public override int Serialize(int offset, byte[] data, EscherSerializationListener listener){listener.BeforeRecordSerialize(offset, RecordId, this);if (remainingData == null) remainingData = new byte[0];LittleEndian.PutShort(data, offset, Options);LittleEndian.PutShort(data, offset + 2, RecordId);int remainingBytes = remainingData.Length + (shortRecord ? 8 : 18);LittleEndian.PutInt(data, offset + 4, remainingBytes);LittleEndian.PutShort(data, offset + 8, field_1_flag);LittleEndian.PutShort(data, offset + 10, field_2_col1);LittleEndian.PutShort(data, offset + 12, field_3_dx1);LittleEndian.PutShort(data, offset + 14, field_4_row1);if (!shortRecord){LittleEndian.PutShort(data, offset + 16, field_5_dy1);LittleEndian.PutShort(data, offset + 18, field_6_col2);LittleEndian.PutShort(data, offset + 20, field_7_dx2);LittleEndian.PutShort(data, offset + 22, field_8_row2);LittleEndian.PutShort(data, offset + 24, field_9_dy2);}Array.Copy(remainingData, 0, data, offset + (shortRecord ? 16 : 26), remainingData.Length);int pos = offset + 8 + (shortRecord ? 8 : 18) + remainingData.Length;listener.AfterRecordSerialize(pos, RecordId, pos - offset, this);return pos - offset;}
// Original:
public final void serialize(LittleEndianOutput out) {int nBreaks = _breaks.size();out.writeShort(nBreaks);for (Break aBreak : _breaks) {aBreak.serialize(out);}}

// Translation:
public override void Serialize(ILittleEndianOutput out1){int nBreaks = _breaks.Count;out1.WriteShort(nBreaks);for (int i = 0; i < nBreaks; i++){_breaks[i].Serialize(out1);}}
// Original:
public float baselineTf(float freq) {if (0.0f == freq) return 0.0f;return (freq <= tf_min)? tf_base: (float)Math.sqrt(freq + (tf_base * tf_base) - tf_min);}

// Translation:
public virtual float BaselineTf(float freq){if (0.0f == freq){return 0.0f;}return (freq <= tf_min) ? tf_base : (float)Math.Sqrt(freq + (tf_base * tf_base) - tf_min);}
// Original:
public StringBuilder delete(int start, int end) {delete0(start, end);return this;}

// Translation:
public java.lang.StringBuilder delete(int start, int end){delete0(start, end);return this;}
// Original:
public boolean isError() {return this.type == TYPE_MALFORMED_INPUT|| this.type == TYPE_UNMAPPABLE_CHAR;}

// Translation:
public virtual bool isError(){return this.type == TYPE_MALFORMED_INPUT || this.type == TYPE_UNMAPPABLE_CHAR;}
// Original:
public int getLastSheetIndexFromExternSheetIndex(int externSheetNumber){return linkTable.getLastInternalSheetIndexForExtIndex(externSheetNumber);}

// Translation:
public int GetLastSheetIndexFromExternSheetIndex(int externSheetNumber){return linkTable.GetLastInternalSheetIndexForExtIndex(externSheetNumber);}
// Original:
public PlainTextDictionary(InputStream dictFile) {in = new BufferedReader(IOUtils.getDecodingReader(dictFile, StandardCharsets.UTF_8));}

// Translation:
public PlainTextDictionary(Stream dictFile){@in = IOUtils.GetDecodingReader(dictFile, Encoding.UTF8);}
// Original:
public LittleEndianByteArrayOutputStream(byte[] buf, int startOffset, int maxWriteLen) { if (startOffset < 0 || startOffset > buf.length) {throw new IllegalArgumentException("Specified startOffset (" + startOffset+ ") is out of allowable range (0.." + buf.length + ")");}_buf = buf;_writeIndex = startOffset;_endIndex = startOffset + maxWriteLen;if (_endIndex < startOffset ||  _endIndex > buf.length) {throw new IllegalArgumentException("calculated end index (" + _endIndex+ ") is out of allowable range (" + _writeIndex + ".." + buf.length + ")");}}

// Translation:
public LittleEndianByteArrayOutputStream(byte[] buf, int startOffset, int maxWriteLen){if (startOffset < 0 || startOffset > buf.Length){throw new ArgumentException("Specified startOffset (" + startOffset+ ") is out of allowable range (0.." + buf.Length + ")");}_buf = buf;_writeIndex = startOffset;_endIndex = startOffset + maxWriteLen;if (_endIndex < startOffset || _endIndex > buf.Length){throw new ArgumentException("calculated end index (" + _endIndex+ ") is out of allowable range (" + _writeIndex + ".." + buf.Length + ")");}}
// Original:
public void addRecords(MergeCellsRecord[] mcrs) {for (int i = 0; i < mcrs.length; i++) {addMergeCellsRecord(mcrs[i]);}}

// Translation:
public void AddRecords(MergeCellsRecord[] mcrs){for (int i = 0; i < mcrs.Length; i++){AddMergeCellsRecord(mcrs[i]);}}
// Original:
public DescribeInternetGatewaysResult describeInternetGateways(DescribeInternetGatewaysRequest request) {request = beforeClientExecution(request);return executeDescribeInternetGateways(request);}

// Translation:
public virtual DescribeInternetGatewaysResponse DescribeInternetGateways(DescribeInternetGatewaysRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeInternetGatewaysRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeInternetGatewaysResponseUnmarshaller.Instance;return Invoke<DescribeInternetGatewaysResponse>(request, options);}
// Original:
public void removeLastSaveDateTime() {remove1stProperty(PropertyIDMap.PID_LASTSAVE_DTM);}

// Translation:
public void RemoveLastSaveDateTime(){MutableSection s = (MutableSection)FirstSection;s.RemoveProperty(PropertyIDMap.PID_LASTSAVE_DTM);}
// Original:
public boolean hitEnd() {return hitEndImpl(address);}

// Translation:
public bool hitEnd(){return hitEndImpl(address);}
// Original:
public ListSkillsResult listSkills(ListSkillsRequest request) {request = beforeClientExecution(request);return executeListSkills(request);}

// Translation:
public virtual ListSkillsResponse ListSkills(ListSkillsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListSkillsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListSkillsResponseUnmarshaller.Instance;return Invoke<ListSkillsResponse>(request, options);}
// Original:
public String toString() {return "popMode";}

// Translation:
public override string ToString(){return "popMode";}
// Original:
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final long byte0 = blocks[blocksOffset++] & 0xFF;final long byte1 = blocks[blocksOffset++] & 0xFF;final long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){long byte0 = blocks[blocksOffset++] & 0xFF;long byte1 = blocks[blocksOffset++] & 0xFF;long byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (byte0 << 16) | (byte1 << 8) | byte2;}}
// Original:
public GetCloudFrontOriginAccessIdentityResult getCloudFrontOriginAccessIdentity(GetCloudFrontOriginAccessIdentityRequest request) {request = beforeClientExecution(request);return executeGetCloudFrontOriginAccessIdentity(request);}

// Translation:
public virtual GetCloudFrontOriginAccessIdentityResponse GetCloudFrontOriginAccessIdentity(GetCloudFrontOriginAccessIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCloudFrontOriginAccessIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCloudFrontOriginAccessIdentityResponseUnmarshaller.Instance;return Invoke<GetCloudFrontOriginAccessIdentityResponse>(request, options);}
// Original:
public boolean include(RevWalk walker, RevCommit c) {return false;}

// Translation:
public override bool Include(RevWalk walker, RevCommit c){return false;}
// Original:
public DocumentStoredFieldVisitor() {this.fieldsToAdd = null;}

// Translation:
public DocumentStoredFieldVisitor(){this.fieldsToAdd = null;}
// Original:
public int addConditionalFormatting(CellRangeAddress[] regions, HSSFConditionalFormattingRule[] cfRules) {if (regions == null) {throw new IllegalArgumentException("regions must not be null");}for(CellRangeAddress range : regions) range.validate(SpreadsheetVersion.EXCEL97);if (cfRules == null) {throw new IllegalArgumentException("cfRules must not be null");}if (cfRules.length == 0) {throw new IllegalArgumentException("cfRules must not be empty");}if (cfRules.length > 3) {throw new IllegalArgumentException("Number of rules must not exceed 3");}CFRuleBase[] rules = new CFRuleBase[cfRules.length];for (int i = 0; i != cfRules.length; i++) {rules[i] = cfRules[i].getCfRuleRecord();}CFRecordsAggregate cfra = new CFRecordsAggregate(regions, rules);return _conditionalFormattingTable.add(cfra);}

// Translation:
public int AddConditionalFormatting(CellRangeAddress[] regions, IConditionalFormattingRule[] cfRules){if (regions == null){throw new ArgumentException("regions must not be null");}if (cfRules == null){throw new ArgumentException("cfRules must not be null");}if (cfRules.Length == 0){throw new ArgumentException("cfRules must not be empty");}if (cfRules.Length > 3){throw new ArgumentException("Number of rules must not exceed 3");}CFRuleRecord[] rules = new CFRuleRecord[cfRules.Length];for (int i = 0; i != cfRules.Length; i++){rules[i] = ((HSSFConditionalFormattingRule)cfRules[i]).CfRuleRecord;}CFRecordsAggregate cfra = new CFRecordsAggregate(regions, rules);return _conditionalFormattingTable.Add(cfra);}
// Original:
public FloatBuffer get(float[] dst, int dstOffset, int floatCount) {Arrays.checkOffsetAndCount(dst.length, dstOffset, floatCount);if (floatCount > remaining()) {throw new BufferUnderflowException();}for (int i = dstOffset; i < dstOffset + floatCount; ++i) {dst[i] = get();}return this;}

// Translation:
public virtual java.nio.FloatBuffer get(float[] dst, int dstOffset, int floatCount){java.util.Arrays.checkOffsetAndCount(dst.Length, dstOffset, floatCount);if (floatCount > remaining()){throw new java.nio.BufferUnderflowException();}{for (int i = dstOffset; i < dstOffset + floatCount; ++i){dst[i] = get();}}return this;}
// Original:
public void rewind() {pos = 0;}

// Translation:
public void Rewind(){pos = 0;}
// Original:
public boolean include(TreeWalk walker) {final int cmp = walker.isPathPrefix(raw, raw.length);if (cmp > 0)throw StopWalkException.INSTANCE;return cmp == 0;}

// Translation:
public override bool Include(TreeWalk walker){int cmp = walker.IsPathPrefix(raw, raw.Length);if (cmp > 0){throw StopWalkException.INSTANCE;}return cmp == 0;}
// Original:
public TagDeliveryStreamResult tagDeliveryStream(TagDeliveryStreamRequest request) {request = beforeClientExecution(request);return executeTagDeliveryStream(request);}

// Translation:
public virtual TagDeliveryStreamResponse TagDeliveryStream(TagDeliveryStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = TagDeliveryStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = TagDeliveryStreamResponseUnmarshaller.Instance;return Invoke<TagDeliveryStreamResponse>(request, options);}
// Original:
public NormalisedDecimal normaliseBaseTen() {return NormalisedDecimal.create(_significand, _binaryExponent);}

// Translation:
public NormalisedDecimal NormaliseBaseTen(){return NormalisedDecimal.Create(_significand, _binaryExponent);}
// Original:
public NavigableSet<K> descendingKeySet() {return new BoundedMap(!ascending, from, fromBound, to, toBound).navigableKeySet();}

// Translation:
public java.util.NavigableSet<K> descendingKeySet(){return new java.util.TreeMap<K, V>.BoundedMap(this._enclosing, !this.ascending, this.from, this.fromBound, this.to, this.toBound).navigableKeySet();}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(_row);out.writeShort(_firstCol);int nItems = _xfs.length;for (short xf : _xfs) {out.writeShort(xf);}out.writeShort(_lastCol);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(_row);out1.WriteShort(_first_col);int nItems = _xfs.Length;for (int i = 0; i < nItems; i++){out1.WriteShort(_xfs[i]);}out1.WriteShort(_last_col);}
// Original:
public byte[] toByteArray() {byte[] result = new byte[LONG_SIZE];LittleEndian.putLong( result, 0, fileTime);return result;}

// Translation:
public byte[] ToByteArray(){byte[] result = new byte[SIZE];LittleEndian.PutInt(result, 0 * LittleEndian.INT_SIZE, _dwLowDateTime);LittleEndian.PutInt(result, 1 * LittleEndian.INT_SIZE, _dwHighDateTime);return result;}
// Original:
public DiffCommand diff() {return new DiffCommand(repo);}

// Translation:
public virtual DiffCommand Diff(){return new DiffCommand(repo);}
// Original:
public ModifySnapshotAttributeResult modifySnapshotAttribute(ModifySnapshotAttributeRequest request) {request = beforeClientExecution(request);return executeModifySnapshotAttribute(request);}

// Translation:
public virtual ModifySnapshotAttributeResponse ModifySnapshotAttribute(ModifySnapshotAttributeRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifySnapshotAttributeRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifySnapshotAttributeResponseUnmarshaller.Instance;return Invoke<ModifySnapshotAttributeResponse>(request, options);}
// Original:
public CreateSubnetResult createSubnet(CreateSubnetRequest request) {request = beforeClientExecution(request);return executeCreateSubnet(request);}

// Translation:
public virtual CreateSubnetResponse CreateSubnet(CreateSubnetRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateSubnetRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateSubnetResponseUnmarshaller.Instance;return Invoke<CreateSubnetResponse>(request, options);}
// Original:
@Override public List<E> subList(int start, int end) {return new UnmodifiableRandomAccessList<E>(list.subList(start, end));}

// Translation:
public override java.util.List<E> subList(int start, int end){return new java.util.Collections.UnmodifiableRandomAccessList<E>(list.subList(start, end));}
// Original:
public long getClipboardFormat() throws HPSFException{if (!(getClipboardFormatTag() == CFTAG_WINDOWS))throw new HPSFException("Clipboard Format Tag of Thumbnail must " +"be CFTAG_WINDOWS.");return LittleEndian.getInt(getThumbnail(), OFFSET_CF);}

// Translation:
public long GetClipboardFormat(){if (!(ClipboardFormatTag == CFTAG_WINDOWS))throw new HPSFException("Clipboard Format Tag of Thumbnail must " +"be CFTAG_WINDOWS.");return LittleEndian.GetInt(this.ThumbnailData, OFFSet_CF);}
// Original:
public HSSFDataValidation(CellRangeAddressList regions, DataValidationConstraint constraint) {_regions = regions;_constraint = (DVConstraint)constraint;}

// Translation:
public HSSFDataValidation(CellRangeAddressList regions, IDataValidationConstraint constraint){_regions = regions;_constraint = (DVConstraint)constraint;}
// Original:
public DiffCommand setProgressMonitor(ProgressMonitor monitor) {if (monitor == null) {monitor = NullProgressMonitor.INSTANCE;}this.monitor = monitor;return this;}

// Translation:
public virtual NGit.Api.DiffCommand SetProgressMonitor(ProgressMonitor monitor){this.monitor = monitor;return this;}
// Original:
public DeleteSegmentResult deleteSegment(DeleteSegmentRequest request) {request = beforeClientExecution(request);return executeDeleteSegment(request);}

// Translation:
public virtual DeleteSegmentResponse DeleteSegment(DeleteSegmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSegmentRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSegmentResponseUnmarshaller.Instance;return Invoke<DeleteSegmentResponse>(request, options);}
// Original:
public AcceptVpcPeeringConnectionResult acceptVpcPeeringConnection(AcceptVpcPeeringConnectionRequest request) {request = beforeClientExecution(request);return executeAcceptVpcPeeringConnection(request);}

// Translation:
public virtual AcceptVpcPeeringConnectionResponse AcceptVpcPeeringConnection(AcceptVpcPeeringConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = AcceptVpcPeeringConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = AcceptVpcPeeringConnectionResponseUnmarshaller.Instance;return Invoke<AcceptVpcPeeringConnectionResponse>(request, options);}
// Original:
public final FloatBuffer put(float[] src) {return put(src, 0, src.length);}

// Translation:
public java.nio.FloatBuffer put(float[] src){return put(src, 0, src.Length);}
// Original:
public PortugueseLightStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public PortugueseLightStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public RefPtg(int row, int column, boolean isRowRelative, boolean isColumnRelative) {super(row, column, isRowRelative, isColumnRelative);}

// Translation:
public RefPtg(int row, int column, bool isRowRelative, bool isColumnRelative):base(row, column, isRowRelative, isColumnRelative){Row = row;Column = column;IsRowRelative = isRowRelative;IsColRelative = isColumnRelative;}