yijunyu/c-to-rust huggingface dataset:
// Original:
public ListImagesResult listImages(ListImagesRequest request) {request = beforeClientExecution(request);return executeListImages(request);}

// Translation:
public virtual ListImagesResponse ListImages(ListImagesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListImagesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListImagesResponseUnmarshaller.Instance;return Invoke<ListImagesResponse>(request, options);}
// Original:
public Diff(int ins, int del, int rep, int noop) {INSERT = ins;DELETE = del;REPLACE = rep;NOOP = noop;}

// Translation:
public Diff(int ins, int del, int rep, int noop){INSERT = ins;DELETE = del;REPLACE = rep;NOOP = noop;}
// Original:
public String toFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.append(operands[ 0 ]);buffer.append(",");buffer.append(operands[ 1 ]);return buffer.toString();}

// Translation:
public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append(",");buffer.Append(operands[1]);return buffer.ToString();}
// Original:
public static void setupEnvironment(String[] workbookNames, ForkedEvaluator[] evaluators) {WorkbookEvaluator[] wbEvals = new WorkbookEvaluator[evaluators.length];for (int i = 0; i < wbEvals.length; i++) {wbEvals[i] = evaluators[i]._evaluator;}CollaboratingWorkbooksEnvironment.setup(workbookNames, wbEvals);}

// Translation:
public static void SetupEnvironment(String[] workbookNames, ForkedEvaluator[] Evaluators){WorkbookEvaluator[] wbEvals = new WorkbookEvaluator[Evaluators.Length];for (int i = 0; i < wbEvals.Length; i++){wbEvals[i] = Evaluators[i]._evaluator;}CollaboratingWorkbooksEnvironment.Setup(workbookNames, wbEvals);}
// Original:
public ListPhotoTagsRequest() {super("CloudPhoto", "2017-07-11", "ListPhotoTags", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public ListPhotoTagsRequest(): base("CloudPhoto", "2017-07-11", "ListPhotoTags", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public RandomSamplingFacetsCollector(int sampleSize, long seed) {super(false);this.sampleSize = sampleSize;this.random = new XORShift64Random(seed);this.sampledDocs = null;}

// Translation:
public RandomSamplingFacetsCollector(int sampleSize, long seed): base(false){this.sampleSize = sampleSize;this.random = new XORShift64Random(seed);this.sampledDocs = null;}
// Original:
public AllocateStaticIpResult allocateStaticIp(AllocateStaticIpRequest request) {request = beforeClientExecution(request);return executeAllocateStaticIp(request);}

// Translation:
public virtual AllocateStaticIpResponse AllocateStaticIp(AllocateStaticIpRequest request){var options = new InvokeOptions();options.RequestMarshaller = AllocateStaticIpRequestMarshaller.Instance;options.ResponseUnmarshaller = AllocateStaticIpResponseUnmarshaller.Instance;return Invoke<AllocateStaticIpResponse>(request, options);}
// Original:
public FeatRecord(RecordInputStream in) {futureHeader = new FtrHeader(in);isf_sharedFeatureType = in.readShort();reserved1 = in.readByte();reserved2 = in.readInt();int cref = in.readUShort();cbFeatData = in.readInt();reserved3 = in.readShort();cellRefs = new CellRangeAddress[cref];for(int i=0; i<cellRefs.length; i++) {cellRefs[i] = new CellRangeAddress(in);}switch(isf_sharedFeatureType) {case FeatHdrRecord.SHAREDFEATURES_ISFPROTECTION:sharedFeature = new FeatProtection(in);break;case FeatHdrRecord.SHAREDFEATURES_ISFFEC2:sharedFeature = new FeatFormulaErr2(in);break;case FeatHdrRecord.SHAREDFEATURES_ISFFACTOID:sharedFeature = new FeatSmartTag(in);break;default:logger.log( POILogger.ERROR, "Unknown Shared Feature " + isf_sharedFeatureType + " found!");}}

// Translation:
public FeatRecord(RecordInputStream in1){futureHeader = new FtrHeader(in1);isf_sharedFeatureType = in1.ReadShort();reserved1 = (byte)in1.ReadByte();reserved2 = in1.ReadInt();int cref = in1.ReadUShort();cbFeatData = in1.ReadInt();reserved3 = in1.ReadShort();cellRefs = new CellRangeAddress[cref];for (int i = 0; i < cellRefs.Length; i++){cellRefs[i] = new CellRangeAddress(in1);}switch (isf_sharedFeatureType){case FeatHdrRecord.SHAREDFEATURES_ISFPROTECTION:sharedFeature = new FeatProtection(in1);break;case FeatHdrRecord.SHAREDFEATURES_ISFFEC2:sharedFeature = new FeatFormulaErr2(in1);break;case FeatHdrRecord.SHAREDFEATURES_ISFFACTOID:sharedFeature = new FeatSmartTag(in1);break;default:logger.Log(POILogger.ERROR, "Unknown Shared Feature " + isf_sharedFeatureType + " found!");break;}}
// Original:
public RevCommit tryFastForward(RevCommit newCommit) throws IOException,GitAPIException {Ref head = getHead();ObjectId headId = head.getObjectId();if (headId == null)throw new RefNotFoundException(MessageFormat.format(JGitText.get().refNotResolved, Constants.HEAD));RevCommit headCommit = walk.lookupCommit(headId);if (walk.isMergedInto(newCommit, headCommit))return newCommit;String headName = getHeadName(head);return tryFastForward(headName, headCommit, newCommit);}

// Translation:
public virtual RevCommit TryFastForward(RevCommit newCommit){Ref head = repo.GetRef(Constants.HEAD);if (head == null || head.GetObjectId() == null){throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved, Constants.HEAD));}ObjectId headId = head.GetObjectId();if (headId == null){throw new RefNotFoundException(MessageFormat.Format(JGitText.Get().refNotResolved, Constants.HEAD));}RevCommit headCommit = walk.LookupCommit(headId);if (walk.IsMergedInto(newCommit, headCommit)){return newCommit;}string headName;if (head.IsSymbolic()){headName = head.GetTarget().GetName();}else{headName = "detached HEAD";}return TryFastForward(headName, headCommit, newCommit);}
// Original:
public CreateSnapshotScheduleResult createSnapshotSchedule(CreateSnapshotScheduleRequest request) {request = beforeClientExecution(request);return executeCreateSnapshotSchedule(request);}

// Translation:
public virtual CreateSnapshotScheduleResponse CreateSnapshotSchedule(CreateSnapshotScheduleRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateSnapshotScheduleRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateSnapshotScheduleResponseUnmarshaller.Instance;return Invoke<CreateSnapshotScheduleResponse>(request, options);}
// Original:
public Record getNext() {if(!hasNext()) {throw new RuntimeException("Attempt to read past end of record stream");}_countRead ++;return _list.get(_nextIndex++);}

// Translation:
public Record GetNext(){if (_nextIndex >= _list.Count){throw new Exception("Attempt to Read past end of record stream");}_countRead++;return (Record)_list[_nextIndex++];}
// Original:
public String toString() {return RawParseUtils.decode(buf.toByteArray());}

// Translation:
public override string ToString(){return RawParseUtils.Decode(buf.ToByteArray());}
// Original:
public ListTablesRequest(String exclusiveStartTableName) {setExclusiveStartTableName(exclusiveStartTableName);}

// Translation:
public ListTablesRequest(string exclusiveStartTableName){_exclusiveStartTableName = exclusiveStartTableName;}
// Original:
public EnableAlarmActionsResult enableAlarmActions(EnableAlarmActionsRequest request) {request = beforeClientExecution(request);return executeEnableAlarmActions(request);}

// Translation:
public virtual EnableAlarmActionsResponse EnableAlarmActions(EnableAlarmActionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = EnableAlarmActionsRequestMarshaller.Instance;options.ResponseUnmarshaller = EnableAlarmActionsResponseUnmarshaller.Instance;return Invoke<EnableAlarmActionsResponse>(request, options);}
// Original:
public Builder() {this(true);}

// Translation:
public Builder(): base(){lastDocID = -1;wordNum = -1;word = 0;}
// Original:
public boolean equals(Object obj) {final State other = (State) obj;return is_final == other.is_final&& Arrays.equals(this.labels, other.labels)&& referenceEquals(this.states, other.states);}

// Translation:
public override bool Equals(object obj){State other = (State)obj;return is_final == other.is_final && Arrays.Equals(this.labels, other.labels) && ReferenceEquals(this.states, other.states);}
// Original:
public TokenStream create(TokenStream input) {return new EnglishPossessiveFilter(input);}

// Translation:
public override TokenStream Create(TokenStream input){return new EnglishPossessiveFilter(m_luceneMatchVersion, input);}
// Original:
public void clearFormatting() {_string = cloneStringIfRequired();_string.clearFormatting();addToSSTIfRequired();}

// Translation:
public void ClearFormatting(){_string = CloneStringIfRequired();_string.ClearFormatting();AddToSSTIfRequired();}
// Original:
public int get(int index, long[] arr, int off, int len) {assert len > 0 : "len must be > 0 (got " + len + ")";assert index >= 0 && index < valueCount;len = Math.min(len, valueCount - index);Arrays.fill(arr, off, off + len, 0);return len;}

// Translation:
public override int Get(int index, long[] arr, int off, int len){Debug.Assert(len > 0, "len must be > 0 (got " + len + ")");Debug.Assert(index >= 0 && index < valueCount);len = Math.Min(len, valueCount - index);Arrays.Fill(arr, off, off + len, 0);return len;}
// Original:
public DeleteRouteResponseResult deleteRouteResponse(DeleteRouteResponseRequest request) {request = beforeClientExecution(request);return executeDeleteRouteResponse(request);}

// Translation:
public virtual DeleteRouteResponseResponse DeleteRouteResponse(DeleteRouteResponseRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteRouteResponseRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteRouteResponseResponseUnmarshaller.Instance;return Invoke<DeleteRouteResponseResponse>(request, options);}
// Original:
public String toPrivateString() {return format(true, false);}

// Translation:
public virtual string ToPrivateString(){return Format(true, false);}
// Original:
public CreatePresignedDomainUrlResult createPresignedDomainUrl(CreatePresignedDomainUrlRequest request) {request = beforeClientExecution(request);return executeCreatePresignedDomainUrl(request);}

// Translation:
public virtual CreatePresignedDomainUrlResponse CreatePresignedDomainUrl(CreatePresignedDomainUrlRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePresignedDomainUrlRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePresignedDomainUrlResponseUnmarshaller.Instance;return Invoke<CreatePresignedDomainUrlResponse>(request, options);}
// Original:
public void write(int oneChar) {doWrite(new char[] { (char) oneChar }, 0, 1);}

// Translation:
public override void write(int oneChar){doWrite(new char[] { (char)oneChar }, 0, 1);}
// Original:
public SSTRecord getSSTRecord() {return sstRecord;}

// Translation:
public SSTRecord GetSSTRecord(){return sstRecord;}
// Original:
public String toString() {return "term=" + term + ",field=" + field + ",value=" + valueToString() + ",docIDUpto=" + docIDUpto;}

// Translation:
public override string ToString(){return "term=" + term + ",field=" + field + ",value=" + value;}
// Original:
public boolean isSaturated(FuzzySet bloomFilter, FieldInfo fieldInfo) {return bloomFilter.getSaturation() > 0.9f;}

// Translation:
public override bool IsSaturated(FuzzySet bloomFilter, FieldInfo fieldInfo){return bloomFilter.GetSaturation() > 0.9f;}
// Original:
public Builder(boolean ignoreCase) {this.ignoreCase = ignoreCase;}

// Translation:
public Builder(bool ignoreCase){this.ignoreCase = ignoreCase;}
// Original:
public String toString() {return getClass().getName()+ "(maxBasicQueries: " + maxBasicQueries+ ", queriesMade: " + queriesMade+ ")";}

// Translation:
public override string ToString(){return GetType().Name+ "(maxBasicQueries: " + maxBasicQueries+ ", queriesMade: " + queriesMade+ ")";}
// Original:
public DeleteDataSourceResult deleteDataSource(DeleteDataSourceRequest request) {request = beforeClientExecution(request);return executeDeleteDataSource(request);}

// Translation:
public virtual DeleteDataSourceResponse DeleteDataSource(DeleteDataSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDataSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDataSourceResponseUnmarshaller.Instance;return Invoke<DeleteDataSourceResponse>(request, options);}
// Original:
public RebootNodeResult rebootNode(RebootNodeRequest request) {request = beforeClientExecution(request);return executeRebootNode(request);}

// Translation:
public virtual RebootNodeResponse RebootNode(RebootNodeRequest request){var options = new InvokeOptions();options.RequestMarshaller = RebootNodeRequestMarshaller.Instance;options.ResponseUnmarshaller = RebootNodeResponseUnmarshaller.Instance;return Invoke<RebootNodeResponse>(request, options);}
// Original:
public void processChildRecords() {convertRawBytesToEscherRecords();}

// Translation:
public void ProcessChildRecords(){ConvertRawBytesToEscherRecords();}
// Original:
public CreateOrUpdateTagsResult createOrUpdateTags(CreateOrUpdateTagsRequest request) {request = beforeClientExecution(request);return executeCreateOrUpdateTags(request);}

// Translation:
public virtual CreateOrUpdateTagsResponse CreateOrUpdateTags(CreateOrUpdateTagsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateOrUpdateTagsRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateOrUpdateTagsResponseUnmarshaller.Instance;return Invoke<CreateOrUpdateTagsResponse>(request, options);}
// Original:
public FileSnapshot getSnapShot() {return snapShot;}

// Translation:
public FileSnapshot GetSnapShot(){return snapShot;}
// Original:
public InputStream openResource(String resource) throws IOException {final InputStream stream = (clazz != null) ?clazz.getResourceAsStream(resource) :loader.getResourceAsStream(resource);if (stream == null)throw new IOException("Resource not found: " + resource);return stream;}

// Translation:
public Stream OpenResource(string resource){Stream stream = this.clazz.GetTypeInfo().Assembly.FindAndGetManifestResourceStream(clazz, resource);if (stream == null){throw new IOException("Resource not found: " + resource);}return stream;}
// Original:
public String toString() {StringBuilder sb = new StringBuilder(64);sb.append(getClass().getName()).append(" [");sb.append("sid=").append(HexDump.shortToHex(_sid));sb.append(" size=").append(_data.length);sb.append(" : ").append(HexDump.toHex(_data));sb.append("]\n");return sb.toString();}

// Translation:
public override String ToString(){StringBuilder sb = new StringBuilder(64);sb.Append(GetType().Name).Append(" [");sb.Append("sid=").Append(HexDump.ShortToHex(_sid));sb.Append(" size=").Append(_data.Length);sb.Append(" : ").Append(HexDump.ToHex(_data));sb.Append("]\n");return sb.ToString();}
// Original:
public int nextIndex() {return index;}

// Translation:
public virtual int nextIndex(){return index;}
// Original:
public CharSequence toQueryString(EscapeQuerySyntax escaper) {if (isDefaultField(this.field)) {return "\"" + getTermEscapeQuoted(escaper) + "\"";} else {return this.field + ":" + "\"" + getTermEscapeQuoted(escaper) + "\"";}}

// Translation:
public override string ToQueryString(IEscapeQuerySyntax escaper){if (IsDefaultField(this.m_field)){return "\"" + GetTermEscapeQuoted(escaper) + "\"";}else{return this.m_field + ":" + "\"" + GetTermEscapeQuoted(escaper) + "\"";}}
// Original:
public CalcModeRecord clone() {return copy();}

// Translation:
public override Object Clone(){CalcModeRecord rec = new CalcModeRecord();rec.field_1_calcmode = field_1_calcmode;return rec;}
// Original:
public boolean isOutput() {return output;}

// Translation:
public virtual bool IsOutput(){return output;}
// Original:
public CreateNetworkInterfaceResult createNetworkInterface(CreateNetworkInterfaceRequest request) {request = beforeClientExecution(request);return executeCreateNetworkInterface(request);}

// Translation:
public virtual CreateNetworkInterfaceResponse CreateNetworkInterface(CreateNetworkInterfaceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateNetworkInterfaceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateNetworkInterfaceResponseUnmarshaller.Instance;return Invoke<CreateNetworkInterfaceResponse>(request, options);}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_password);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_password);}
// Original:
public StopDominantLanguageDetectionJobResult stopDominantLanguageDetectionJob(StopDominantLanguageDetectionJobRequest request) {request = beforeClientExecution(request);return executeStopDominantLanguageDetectionJob(request);}

// Translation:
public virtual StopDominantLanguageDetectionJobResponse StopDominantLanguageDetectionJob(StopDominantLanguageDetectionJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopDominantLanguageDetectionJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StopDominantLanguageDetectionJobResponseUnmarshaller.Instance;return Invoke<StopDominantLanguageDetectionJobResponse>(request, options);}
// Original:
public ECSMetadataServiceCredentialsFetcher withConnectionTimeout(int milliseconds) {this.connectionTimeoutInMilliseconds = milliseconds;return this;}

// Translation:
public void WithConnectionTimeout(int milliseconds){connectionTimeoutInMilliseconds = milliseconds;}
// Original:
public GetGatewayGroupResult getGatewayGroup(GetGatewayGroupRequest request) {request = beforeClientExecution(request);return executeGetGatewayGroup(request);}

// Translation:
public virtual GetGatewayGroupResponse GetGatewayGroup(GetGatewayGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetGatewayGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = GetGatewayGroupResponseUnmarshaller.Instance;return Invoke<GetGatewayGroupResponse>(request, options);}
// Original:
public FloatBuffer slice() {return new ReadOnlyFloatArrayBuffer(remaining(), backingArray, offset + position);}

// Translation:
public override java.nio.FloatBuffer slice(){return new java.nio.ReadOnlyFloatArrayBuffer(remaining(), backingArray, offset +_position);}
// Original:
public static String join(Collection<String> parts, String separator,String lastSeparator) {StringBuilder sb = new StringBuilder();int i = 0;int lastIndex = parts.size() - 1;for (String part : parts) {sb.append(part);if (i == lastIndex - 1) {sb.append(lastSeparator);} else if (i != lastIndex) {sb.append(separator);}i++;}return sb.toString();}

// Translation:
public static string Join(ICollection<string> parts, string separator, string lastSeparator){StringBuilder sb = new StringBuilder();int i = 0;int lastIndex = parts.Count - 1;foreach (string part in parts){sb.Append(part);if (i == lastIndex - 1){sb.Append(lastSeparator);}else{if (i != lastIndex){sb.Append(separator);}}i++;}return sb.ToString();}
// Original:
public String toString() {return "(" + a.toString() + " AND " + b.toString() + ")"; }

// Translation:
public override string ToString(){return "(" + a.ToString() + " AND " + b.ToString() + ")";}
// Original:
public ListSubscriptionsByTopicRequest(String topicArn, String nextToken) {setTopicArn(topicArn);setNextToken(nextToken);}

// Translation:
public ListSubscriptionsByTopicRequest(string topicArn, string nextToken){_topicArn = topicArn;_nextToken = nextToken;}
// Original:
public byte readByte() {return bytes[pos--];}

// Translation:
public override byte ReadByte(){return bytes[pos--];}
// Original:
public TerminateClientVpnConnectionsResult terminateClientVpnConnections(TerminateClientVpnConnectionsRequest request) {request = beforeClientExecution(request);return executeTerminateClientVpnConnections(request);}

// Translation:
public virtual TerminateClientVpnConnectionsResponse TerminateClientVpnConnections(TerminateClientVpnConnectionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = TerminateClientVpnConnectionsRequestMarshaller.Instance;options.ResponseUnmarshaller = TerminateClientVpnConnectionsResponseUnmarshaller.Instance;return Invoke<TerminateClientVpnConnectionsResponse>(request, options);}
// Original:
public ReceiveMessageRequest(String queueUrl) {setQueueUrl(queueUrl);}

// Translation:
public ReceiveMessageRequest(string queueUrl){_queueUrl = queueUrl;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(field_1_barSpace);out.writeShort(field_2_categorySpace);out.writeShort(field_3_formatFlags);}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(field_1_barSpace);out1.WriteShort(field_2_categorySpace);out1.WriteShort(field_3_formatFlags);}
// Original:
public Object common(Object output1, Object output2) {return outputs.common((T) output1, (T) output2);}

// Translation:
public override object Common(object output1, object output2){return outputs.Common((T)output1, (T)output2);}
// Original:
public CreateVariableResult createVariable(CreateVariableRequest request) {request = beforeClientExecution(request);return executeCreateVariable(request);}

// Translation:
public virtual CreateVariableResponse CreateVariable(CreateVariableRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateVariableRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateVariableResponseUnmarshaller.Instance;return Invoke<CreateVariableResponse>(request, options);}
// Original:
public static final int match(byte[] b, int ptr, byte[] src) {if (ptr + src.length > b.length)return -1;for (int i = 0; i < src.length; i++, ptr++)if (b[ptr] != src[i])return -1;return ptr;}

// Translation:
public static int Match(byte[] b, int ptr, byte[] src){if (ptr + src.Length > b.Length){return -1;}for (int i = 0; i < src.Length; i++, ptr++){if (b[ptr] != src[i]){return -1;}}return ptr;}
// Original:
public int fillFields(byte[] data, int offset, EscherRecordFactory recordFactory) {int bytesRemaining = readHeader( data, offset );int pos            = offset + 8;int size           = 0;field_1_rectX1 =  LittleEndian.getInt( data, pos + size );size+=4;field_2_rectY1 =  LittleEndian.getInt( data, pos + size );size+=4;field_3_rectX2 =  LittleEndian.getInt( data, pos + size );size+=4;field_4_rectY2 =  LittleEndian.getInt( data, pos + size );size+=4;bytesRemaining -= size;if (bytesRemaining != 0) {throw new RecordFormatException("Expected no remaining bytes but got " + bytesRemaining);}return 8 + size + bytesRemaining;}

// Translation:
public override int FillFields(byte[] data, int offset, IEscherRecordFactory recordFactory){int bytesRemaining = ReadHeader(data, offset);int pos = offset + 8;int size = 0;field_1_rectX1 = LittleEndian.GetInt(data, pos + size); size += 4;field_2_rectY1 = LittleEndian.GetInt(data, pos + size); size += 4;field_3_rectX2 = LittleEndian.GetInt(data, pos + size); size += 4;field_4_rectY2 = LittleEndian.GetInt(data, pos + size); size += 4;bytesRemaining -= size;if (bytesRemaining != 0) throw new RecordFormatException("Expected no remaining bytes but got " + bytesRemaining);return 8 + size + bytesRemaining;}
// Original:
public CreateCloudFrontOriginAccessIdentityResult createCloudFrontOriginAccessIdentity(CreateCloudFrontOriginAccessIdentityRequest request) {request = beforeClientExecution(request);return executeCreateCloudFrontOriginAccessIdentity(request);}

// Translation:
public virtual CreateCloudFrontOriginAccessIdentityResponse CreateCloudFrontOriginAccessIdentity(CreateCloudFrontOriginAccessIdentityRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCloudFrontOriginAccessIdentityRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCloudFrontOriginAccessIdentityResponseUnmarshaller.Instance;return Invoke<CreateCloudFrontOriginAccessIdentityResponse>(request, options);}
// Original:
public boolean isNamespaceAware() {return getFeature (XmlPullParser.FEATURE_PROCESS_NAMESPACES);}

// Translation:
public virtual bool isNamespaceAware(){return getFeature(org.xmlpull.v1.XmlPullParserClass.FEATURE_PROCESS_NAMESPACES);}
// Original:
public void setOverridable(boolean on) {overridable = on;}

// Translation:
public virtual void SetOverridable(bool on){overridable = on;}