yijunyu/c-to-rust huggingface dataset:
// Original:
public ModifyTransitGatewayVpcAttachmentResult modifyTransitGatewayVpcAttachment(ModifyTransitGatewayVpcAttachmentRequest request) {request = beforeClientExecution(request);return executeModifyTransitGatewayVpcAttachment(request);}

// Translation:
public virtual ModifyTransitGatewayVpcAttachmentResponse ModifyTransitGatewayVpcAttachment(ModifyTransitGatewayVpcAttachmentRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyTransitGatewayVpcAttachmentRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyTransitGatewayVpcAttachmentResponseUnmarshaller.Instance;return Invoke<ModifyTransitGatewayVpcAttachmentResponse>(request, options);}
// Original:
public RejectSkillResult rejectSkill(RejectSkillRequest request) {request = beforeClientExecution(request);return executeRejectSkill(request);}

// Translation:
public virtual RejectSkillResponse RejectSkill(RejectSkillRequest request){var options = new InvokeOptions();options.RequestMarshaller = RejectSkillRequestMarshaller.Instance;options.ResponseUnmarshaller = RejectSkillResponseUnmarshaller.Instance;return Invoke<RejectSkillResponse>(request, options);}
// Original:
public String getHexString() {return getGnumericPart(_red) + ":" + getGnumericPart(_green) + ":" + getGnumericPart(_blue);}

// Translation:
public override String GetHexString(){StringBuilder sb = new StringBuilder();sb.Append(GetGnumericPart(red));sb.Append(':');sb.Append(GetGnumericPart(green));sb.Append(':');sb.Append(GetGnumericPart(blue));return sb.ToString();}
// Original:
public String toString() {return "<prefixWildcard field='" + this.field + "' term='" + this.text+ "'/>";}

// Translation:
public override string ToString(){return "<prefixWildcard field='" + this.m_field + "' term='" + this.m_text+ "'/>";}
// Original:
public GetOSSImageAccessRequest() {super("industry-brain", "2018-07-12", "GetOSSImageAccess");setProtocol(ProtocolType.HTTPS);}

// Translation:
public GetOSSImageAccessRequest(): base("industry-brain", "2018-07-12", "GetOSSImageAccess"){Protocol = ProtocolType.HTTPS;}
// Original:
public DeleteFleetsResult deleteFleets(DeleteFleetsRequest request) {request = beforeClientExecution(request);return executeDeleteFleets(request);}

// Translation:
public virtual DeleteFleetsResponse DeleteFleets(DeleteFleetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteFleetsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteFleetsResponseUnmarshaller.Instance;return Invoke<DeleteFleetsResponse>(request, options);}
// Original:
public void set(E object) {if (expectedModCount == modCount) {try {AbstractList.this.set(lastPosition, object);} catch (IndexOutOfBoundsException e) {throw new IllegalStateException();}} else {throw new ConcurrentModificationException();}}

// Translation:
public void set(E @object){if (this.expectedModCount == this._enclosing.modCount){try{this._enclosing.set(this.lastPosition, @object);}catch (System.IndexOutOfRangeException){throw new System.InvalidOperationException();}}else{throw new java.util.ConcurrentModificationException();}}
// Original:
public InvalidationBatch(Paths paths, String callerReference) {setPaths(paths);setCallerReference(callerReference);}

// Translation:
public InvalidationBatch(Paths paths, string callerReference){_paths = paths;_callerReference = callerReference;}
// Original:
public int getPrecision() {return p;}

// Translation:
public virtual int getPrecision(){return p;}
// Original:
public boolean addSubRecord(SubRecord o) {return subrecords.add(o);}

// Translation:
public void AddSubRecord(SubRecord o){subrecords.Add(o);}
// Original:
public int serialize(int offset, byte[] data, EscherSerializationListener listener) {listener.beforeRecordSerialize( offset, getRecordId(), this );int pos = offset;LittleEndian.putShort( data, pos, getOptions() );          pos += 2;LittleEndian.putShort( data, pos, getRecordId() );         pos += 2;LittleEndian.putInt( data, pos, getRecordSize()-8 );       pos += 4;LittleEndian.putInt( data, pos, field_1_dx1 );             pos += 4;LittleEndian.putInt( data, pos, field_2_dy1 );             pos += 4;LittleEndian.putInt( data, pos, field_3_dx2 );             pos += 4;LittleEndian.putInt( data, pos, field_4_dy2 );             pos += 4;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);int pos = offset;LittleEndian.PutShort(data, pos, Options); pos += 2;LittleEndian.PutShort(data, pos, RecordId); pos += 2;LittleEndian.PutInt(data, pos, RecordSize - 8); pos += 4;LittleEndian.PutInt(data, pos, field_1_dx1); pos += 4;LittleEndian.PutInt(data, pos, field_2_dy1); pos += 4;LittleEndian.PutInt(data, pos, field_3_dx2); pos += 4;LittleEndian.PutInt(data, pos, field_4_dy2); pos += 4;listener.AfterRecordSerialize(pos, RecordId, pos - offset, this);return pos - offset;}
// Original:
public static final ObjectId fromRaw(int[] is) {return fromRaw(is, 0);}

// Translation:
public static NGit.ObjectId FromRaw(byte[] bs){return FromRaw(bs, 0);}
// Original:
public DisassociateIpGroupsResult disassociateIpGroups(DisassociateIpGroupsRequest request) {request = beforeClientExecution(request);return executeDisassociateIpGroups(request);}

// Translation:
public virtual DisassociateIpGroupsResponse DisassociateIpGroups(DisassociateIpGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DisassociateIpGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DisassociateIpGroupsResponseUnmarshaller.Instance;return Invoke<DisassociateIpGroupsResponse>(request, options);}
// Original:
public static void mkdirs(File d, boolean skipExisting)throws IOException {if (!d.mkdirs()) {if (skipExisting && d.isDirectory())return;throw new IOException(MessageFormat.format(JGitText.get().mkDirsFailed, d.getAbsolutePath()));}}

// Translation:
public static void Mkdirs(FilePath d, bool skipExisting){if (!d.Mkdirs()){if (skipExisting && d.IsDirectory()){return;}throw new IOException(MessageFormat.Format(JGitText.Get().mkDirsFailed, d.GetAbsolutePath()));}}
// Original:
public GetImageManifestRequest() {super("cr", "2016-06-07", "GetImageManifest", "cr");setUriPattern("/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/manifest");setMethod(MethodType.GET);}

// Translation:
public GetImageManifestRequest(): base("cr", "2016-06-07", "GetImageManifest", "cr", "openAPI"){UriPattern = "/repos/[RepoNamespace]/[RepoName]/tags/[Tag]/manifest";Method = MethodType.GET;}
// Original:
public ListIdentitiesResult listIdentities(ListIdentitiesRequest request) {request = beforeClientExecution(request);return executeListIdentities(request);}

// Translation:
public virtual ListIdentitiesResponse ListIdentities(ListIdentitiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListIdentitiesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListIdentitiesResponseUnmarshaller.Instance;return Invoke<ListIdentitiesResponse>(request, options);}
// Original:
public final String toString() {return getClass().getName() + " [" +_sfr.getRange() +"]";}

// Translation:
public override String ToString(){StringBuilder sb = new StringBuilder(64);sb.Append(GetType().Name).Append(" [");sb.Append(_sfr.Range.ToString());sb.Append("]");return sb.ToString();}
// Original:
public byte[] toByteArray() {byte[] result = new byte[LittleEndianConsts.INT_SIZE*2+_value.length];LittleEndianByteArrayOutputStream bos = new LittleEndianByteArrayOutputStream(result,0);try {bos.writeInt(LittleEndianConsts.INT_SIZE + _value.length);bos.writeInt(_format);bos.write(_value);return result;} finally {IOUtils.closeQuietly(bos);}}

// Translation:
public byte[] ToByteArray(){byte[] result = new byte[Size];LittleEndian.PutInt(result, 0 * LittleEndian.INT_SIZE,LittleEndian.INT_SIZE + _value.Length);LittleEndian.PutInt(result, 1 * LittleEndian.INT_SIZE, _format);System.Array.Copy(_value, 0, result, LittleEndian.INT_SIZE+ LittleEndian.INT_SIZE, _value.Length);return result;}
// Original:
public void update(byte[] b, int off, int len) {if (len >= buffer.length) {flush();in.update(b, off, len);} else {if (upto + len > buffer.length) {flush();}System.arraycopy(b, off, buffer, upto, len);upto += len;}}

// Translation:
public virtual void Update(byte[] b, int off, int len){if (len >= buffer.Length){Flush();@in.Update(b, off, len);}else{if (upto + len > buffer.Length){Flush();}System.Buffer.BlockCopy(b, off, buffer, upto, len);upto += len;}}
// Original:
public HSSFPicture createPicture(ClientAnchor anchor, int pictureIndex) {return createPicture((HSSFClientAnchor) anchor, pictureIndex);}

// Translation:
public IPicture CreatePicture(HSSFClientAnchor anchor, int pictureIndex){HSSFPicture shape = new HSSFPicture(null, (HSSFClientAnchor)anchor);shape.PictureIndex = pictureIndex;AddShape(shape);OnCreate(shape);return shape;}
// Original:
public String getAccessKeySecret() {return legacyCredential.getAccessSecret();}

// Translation:
public string GetAccessKeySecret(){return legacyCredential.AccessSecret;}
// Original:
public int compareTo(ByteBuffer otherBuffer) {int compareRemaining = (remaining() < otherBuffer.remaining()) ? remaining(): otherBuffer.remaining();int thisPos = position;int otherPos = otherBuffer.position;byte thisByte, otherByte;while (compareRemaining > 0) {thisByte = get(thisPos);otherByte = otherBuffer.get(otherPos);if (thisByte != otherByte) {return thisByte < otherByte ? -1 : 1;}thisPos++;otherPos++;compareRemaining--;}return remaining() - otherBuffer.remaining();}

// Translation:
public virtual int compareTo(java.nio.ByteBuffer otherBuffer){int compareRemaining = (remaining() < otherBuffer.remaining()) ? remaining() : otherBuffer.remaining();int thisPos = _position;int otherPos = otherBuffer._position;byte thisByte;byte otherByte;while (compareRemaining > 0){thisByte = get(thisPos);otherByte = otherBuffer.get(otherPos);if (thisByte != otherByte){return ((sbyte)thisByte) < otherByte ? -1 : 1;}thisPos++;otherPos++;compareRemaining--;}return remaining() - otherBuffer.remaining();}
// Original:
public CreateResolverEndpointResult createResolverEndpoint(CreateResolverEndpointRequest request) {request = beforeClientExecution(request);return executeCreateResolverEndpoint(request);}

// Translation:
public virtual CreateResolverEndpointResponse CreateResolverEndpoint(CreateResolverEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateResolverEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateResolverEndpointResponseUnmarshaller.Instance;return Invoke<CreateResolverEndpointResponse>(request, options);}
// Original:
public HunspellStemFilterFactory(Map<String,String> args) {super(args);dictionaryFiles = require(args, PARAM_DICTIONARY);affixFile = get(args, PARAM_AFFIX);ignoreCase = getBoolean(args, PARAM_IGNORE_CASE, false);longestOnly = getBoolean(args, PARAM_LONGEST_ONLY, false);getBoolean(args, "strictAffixParsing", true);getInt(args, "recursionCap", 0);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public HunspellStemFilterFactory(IDictionary<string, string> args): base(args){dictionaryFiles = Require(args, PARAM_DICTIONARY);affixFile = Get(args, PARAM_AFFIX);ignoreCase = GetBoolean(args, PARAM_IGNORE_CASE, false);longestOnly = GetBoolean(args, PARAM_LONGEST_ONLY, false);GetBoolean(args, "strictAffixParsing", true);GetInt32(args, "recursionCap", 0);if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {for (int j = 0; j < iterations; ++j) {final byte block = blocks[blocksOffset++];values[valuesOffset++] = (block >>> 4) & 15;values[valuesOffset++] = block & 15;}}

// Translation:
public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int j = 0; j < iterations; ++j){var block = blocks[blocksOffset++];values[valuesOffset++] = ((int)((uint)block >> 4)) & 15;values[valuesOffset++] = block & 15;}}
// Original:
public CancelSpotInstanceRequestsResult cancelSpotInstanceRequests(CancelSpotInstanceRequestsRequest request) {request = beforeClientExecution(request);return executeCancelSpotInstanceRequests(request);}

// Translation:
public virtual CancelSpotInstanceRequestsResponse CancelSpotInstanceRequests(CancelSpotInstanceRequestsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CancelSpotInstanceRequestsRequestMarshaller.Instance;options.ResponseUnmarshaller = CancelSpotInstanceRequestsResponseUnmarshaller.Instance;return Invoke<CancelSpotInstanceRequestsResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_print_headers);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_print_headers);}
// Original:
public void copyTo(char[] tmp, StringBuilder w) {toHexCharArray(tmp);w.append(tmp, 0, Constants.OBJECT_ID_STRING_LENGTH);}

// Translation:
public virtual void CopyTo(char[] tmp, TextWriter w){ToHexCharArray(tmp);w.Write(tmp, 0, Constants.OBJECT_ID_STRING_LENGTH);}
// Original:
public DeleteVaultAccessPolicyResult deleteVaultAccessPolicy(DeleteVaultAccessPolicyRequest request) {request = beforeClientExecution(request);return executeDeleteVaultAccessPolicy(request);}

// Translation:
public virtual DeleteVaultAccessPolicyResponse DeleteVaultAccessPolicy(DeleteVaultAccessPolicyRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVaultAccessPolicyRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVaultAccessPolicyResponseUnmarshaller.Instance;return Invoke<DeleteVaultAccessPolicyResponse>(request, options);}
// Original:
public SpanOrBuilder(SpanQueryBuilder factory) {this.factory = factory;}

// Translation:
public SpanOrBuilder(ISpanQueryBuilder factory){this.factory = factory;}
// Original:
public DescribeConnectionsOnInterconnectResult describeConnectionsOnInterconnect(DescribeConnectionsOnInterconnectRequest request) {request = beforeClientExecution(request);return executeDescribeConnectionsOnInterconnect(request);}

// Translation:
public virtual DescribeConnectionsOnInterconnectResponse DescribeConnectionsOnInterconnect(DescribeConnectionsOnInterconnectRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeConnectionsOnInterconnectRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeConnectionsOnInterconnectResponseUnmarshaller.Instance;return Invoke<DescribeConnectionsOnInterconnectResponse>(request, options);}
// Original:
public MultiBoolFunction(List<ValueSource> sources) {this.sources = sources;}

// Translation:
public MultiBoolFunction(IList<ValueSource> sources){this.m_sources = sources;}
// Original:
public TokenStream create(TokenStream input) {return new ICUTransformFilter(input, transliterator);}

// Translation:
public override TokenStream Create(TokenStream input){return new ICUTransformFilter(input, transliterator);}
// Original:
public void extendA() {endA++;}

// Translation:
public virtual void ExtendA(){endA++;}
// Original:
public DeleteReceiptRuleSetResult deleteReceiptRuleSet(DeleteReceiptRuleSetRequest request) {request = beforeClientExecution(request);return executeDeleteReceiptRuleSet(request);}

// Translation:
public virtual DeleteReceiptRuleSetResponse DeleteReceiptRuleSet(DeleteReceiptRuleSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteReceiptRuleSetRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteReceiptRuleSetResponseUnmarshaller.Instance;return Invoke<DeleteReceiptRuleSetResponse>(request, options);}
// Original:
public PutRetentionPolicyRequest(String logGroupName, Integer retentionInDays) {setLogGroupName(logGroupName);setRetentionInDays(retentionInDays);}

// Translation:
public PutRetentionPolicyRequest(string logGroupName, int retentionInDays){_logGroupName = logGroupName;_retentionInDays = retentionInDays;}
// Original:
public void insertRow(RowRecord row) {_rowRecords.put(Integer.valueOf(row.getRowNumber()), row);_rowRecordValues = null;if ((row.getRowNumber() < _firstrow) || (_firstrow == -1)) {_firstrow = row.getRowNumber();}if ((row.getRowNumber() > _lastrow) || (_lastrow == -1)) {_lastrow = row.getRowNumber();}}

// Translation:
public void InsertRow(RowRecord row){_rowRecords[row.RowNumber] = row;_rowRecordValues = null;if (row.RowNumber < firstrow|| firstrow == -1){firstrow = row.RowNumber;}if (row.RowNumber > lastrow|| lastrow == -1){lastrow = row.RowNumber;}}
// Original:
public String toString() {return "TermState";}

// Translation:
public override string ToString(){return "TermState";}
// Original:
public LsRemoteCommand setHeads(boolean heads) {this.heads = heads;return this;}

// Translation:
public virtual NGit.Api.LsRemoteCommand SetHeads(bool heads){this.heads = heads;return this;}
// Original:
public void remove(String key) {deleteNode(getNode(key.trim().toLowerCase(locale)));}

// Translation:
public virtual void Remove(string key){DeleteNode(GetNode(this.culture.TextInfo.ToLower(key.Trim())));}
// Original:
public Object[][] getTokenArrayValues() {if (_arrayValues == null) {throw new IllegalStateException("array values not read yet");}Object[][] result = new Object[_nRows][_nColumns];for (int r = 0; r < _nRows; r++) {Object[] rowData = result[r];for (int c = 0; c < _nColumns; c++) {rowData[c] = _arrayValues[getValueIndex(c, r)];}}return result;}

// Translation:
public Object[][] GetTokenArrayValues(){if (_arrayValues == null){throw new InvalidOperationException("array values not read yet");}Object[][] result = new Object[_nRows][];for (int r = 0; r < _nRows; r++){result[r] = new object[_nColumns];for (int c = 0; c < _nColumns; c++){result[r][c] = _arrayValues[GetValueIndex(c, r)];}}return result;}
// Original:
public PutIntegrationResponseResult putIntegrationResponse(PutIntegrationResponseRequest request) {request = beforeClientExecution(request);return executePutIntegrationResponse(request);}

// Translation:
public virtual PutIntegrationResponseResponse PutIntegrationResponse(PutIntegrationResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = PutIntegrationResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = PutIntegrationResponseResponseUnmarshaller.Instance;return Invoke<PutIntegrationResponseResponse>(request, options);}
// Original:
public void write(String str, int offset, int count) throws IOException {synchronized (lock) {if (count < 0) {throw new StringIndexOutOfBoundsException(str, offset, count);}if (str == null) {throw new NullPointerException("str == null");}if ((offset | count) < 0 || offset > str.length() - count) {throw new StringIndexOutOfBoundsException(str, offset, count);}checkStatus();CharBuffer chars = CharBuffer.wrap(str, offset, count + offset);convert(chars);}}

// Translation:
public override void write(string str, int offset, int count){lock (@lock){if (count < 0){throw new java.lang.StringIndexOutOfBoundsException(str, offset, count);}if (str == null){throw new System.ArgumentNullException("str == null");}if ((offset | count) < 0 || offset > str.Length - count){throw new java.lang.StringIndexOutOfBoundsException(str, offset, count);}checkStatus();java.nio.CharBuffer chars = java.nio.CharBuffer.wrap(java.lang.CharSequenceProxy.Wrap(str), offset, count + offset);convert(chars);}}
// Original:
public String subscriptionId() {return this.subscriptionId;}

// Translation:
public string SubscriptionId { get; set; }
// Original:
public HSSFPicture createPicture(HSSFClientAnchor anchor, int pictureIndex) {HSSFPicture shape = new HSSFPicture(null, anchor);shape.setPictureIndex(pictureIndex);addShape(shape);onCreate(shape);return shape;}

// Translation:
public IPicture CreatePicture(HSSFClientAnchor anchor, int pictureIndex){HSSFPicture shape = new HSSFPicture(null, (HSSFClientAnchor)anchor);shape.PictureIndex = pictureIndex;AddShape(shape);OnCreate(shape);return shape;}
// Original:
public ReleaseStaticIpResult releaseStaticIp(ReleaseStaticIpRequest request) {request = beforeClientExecution(request);return executeReleaseStaticIp(request);}

// Translation:
public virtual ReleaseStaticIpResponse ReleaseStaticIp(ReleaseStaticIpRequest request){var options = new InvokeOptions();options.RequestMarshaller = ReleaseStaticIpRequestMarshaller.Instance;options.ResponseUnmarshaller = ReleaseStaticIpResponseUnmarshaller.Instance;return Invoke<ReleaseStaticIpResponse>(request, options);}
// Original:
public ListConfigurationSetsResult listConfigurationSets(ListConfigurationSetsRequest request) {request = beforeClientExecution(request);return executeListConfigurationSets(request);}

// Translation:
public virtual ListConfigurationSetsResponse ListConfigurationSets(ListConfigurationSetsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListConfigurationSetsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListConfigurationSetsResponseUnmarshaller.Instance;return Invoke<ListConfigurationSetsResponse>(request, options);}
// Original:
public UpdateRecordsResult updateRecords(UpdateRecordsRequest request) {request = beforeClientExecution(request);return executeUpdateRecords(request);}

// Translation:
public virtual UpdateRecordsResponse UpdateRecords(UpdateRecordsRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRecordsRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRecordsResponseUnmarshaller.Instance;return Invoke<UpdateRecordsResponse>(request, options);}
// Original:
public Token emit() {Token t = _factory.create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex, getCharIndex()-1,_tokenStartLine, _tokenStartCharPositionInLine);emit(t);return t;}

// Translation:
public virtual IToken Emit(){IToken t = _factory.Create(_tokenFactorySourcePair, _type, _text, _channel, _tokenStartCharIndex, CharIndex - 1, _tokenStartLine, _tokenStartColumn);Emit(t);return t;}
// Original:
public synchronized IndexCommit snapshot() throws IOException {if (!initCalled) {throw new IllegalStateException("this instance is not being used by IndexWriter; be sure to use the instance returned from writer.getConfig().getIndexDeletionPolicy()");}if (lastCommit == null) {throw new IllegalStateException("No index commit to snapshot");}incRef(lastCommit);return lastCommit;}

// Translation:
public virtual IndexCommit Snapshot(){lock (this){if (!initCalled){throw new InvalidOperationException("this instance is not being used by IndexWriter; be sure to use the instance returned from writer.getConfig().getIndexDeletionPolicy()");}if (m_lastCommit == null){throw new InvalidOperationException("No index commit to snapshot");}IncRef(m_lastCommit);return m_lastCommit;}}