yijunyu/c-to-rust huggingface dataset:
// Original:
public StartTopicsDetectionJobResult startTopicsDetectionJob(StartTopicsDetectionJobRequest request) {request = beforeClientExecution(request);return executeStartTopicsDetectionJob(request);}

// Translation:
public virtual StartTopicsDetectionJobResponse StartTopicsDetectionJob(StartTopicsDetectionJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartTopicsDetectionJobRequestMarshaller.Instance;options.ResponseUnmarshaller = StartTopicsDetectionJobResponseUnmarshaller.Instance;return Invoke<StartTopicsDetectionJobResponse>(request, options);}
// Original:
public ClusterSecurityGroup revokeClusterSecurityGroupIngress(RevokeClusterSecurityGroupIngressRequest request) {request = beforeClientExecution(request);return executeRevokeClusterSecurityGroupIngress(request);}

// Translation:
public virtual RevokeClusterSecurityGroupIngressResponse RevokeClusterSecurityGroupIngress(RevokeClusterSecurityGroupIngressRequest request){var options = new InvokeOptions();options.RequestMarshaller = RevokeClusterSecurityGroupIngressRequestMarshaller.Instance;options.ResponseUnmarshaller = RevokeClusterSecurityGroupIngressResponseUnmarshaller.Instance;return Invoke<RevokeClusterSecurityGroupIngressResponse>(request, options);}
// Original:
public void enterRule(ParserRuleContext localctx, int state, int ruleIndex) {setState(state);_ctx = localctx;_ctx.start = _input.LT(1);if (_buildParseTrees) addContextToParseTree();if ( _parseListeners != null) triggerEnterRuleEvent();}

// Translation:
public virtual void EnterRule(ParserRuleContext localctx, int state, int ruleIndex){State = state;_ctx = localctx;_ctx.Start = _input.LT(1);if (_buildParseTrees){AddContextToParseTree();}if (_parseListeners != null){TriggerEnterRuleEvent();}}
// Original:
public ObjectReader newReader() {return new WindowCursor(db);}

// Translation:
public override ObjectReader NewReader(){return new NGit.Storage.File.WindowCursor(db);}
// Original:
@Override public int size() {return backingMap.size();}

// Translation:
public override int size(){return this._enclosing._size;}
// Original:
public static String pathToString(String[] path, int length) {if (length == 0) {return "";}StringBuilder sb = new StringBuilder();for(int i=0;i<length;i++) {String s = path[i];if (s.length() == 0) {throw new IllegalArgumentException("each path component must have length > 0 (got: \"\")");}int numChars = s.length();for(int j=0;j<numChars;j++) {char ch = s.charAt(j);if (ch == DELIM_CHAR || ch == ESCAPE_CHAR) {sb.append(ESCAPE_CHAR);}sb.append(ch);}sb.append(DELIM_CHAR);}sb.setLength(sb.length()-1);return sb.toString();}

// Translation:
public static string PathToString(string[] path, int length){if (length == 0){return "";}StringBuilder sb = new StringBuilder();for (int i = 0; i < length; i++){string s = path[i];if (s.Length == 0){throw new System.ArgumentException("each path component must have length > 0 (got: \"\")");}int numChars = s.Length;for (int j = 0; j < numChars; j++){char ch = s[j];if (ch == DELIM_CHAR || ch == ESCAPE_CHAR){sb.Append(ESCAPE_CHAR);}sb.Append(ch);}sb.Append(DELIM_CHAR);}sb.Length = sb.Length - 1;return sb.ToString();}
// Original:
public CancelSpotInstanceRequestsRequest(java.util.List<String> spotInstanceRequestIds) {setSpotInstanceRequestIds(spotInstanceRequestIds);}

// Translation:
public CancelSpotInstanceRequestsRequest(List<string> spotInstanceRequestIds){_spotInstanceRequestIds = spotInstanceRequestIds;}
// Original:
public String toString() {StringBuilder sb = new StringBuilder();sb.append('[');for (byte[] b : table) {if (b == null)continue;if (sb.length() > 1)sb.append(" , "); sb.append('"');sb.append(RawParseUtils.decode(b));sb.append('"');sb.append('(');sb.append(chainlength(b));sb.append(')');}sb.append(']');return sb.toString();}

// Translation:
public override string ToString(){StringBuilder r = new StringBuilder();r.Append("(");for (int i = 0; i < subfilters.Length; i++){if (i > 0){r.Append(" OR ");}r.Append(subfilters[i].ToString());}r.Append(")");return r.ToString();}
// Original:
public GetConnectionResult getConnection(GetConnectionRequest request) {request = beforeClientExecution(request);return executeGetConnection(request);}

// Translation:
public virtual GetConnectionResponse GetConnection(GetConnectionRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetConnectionRequestMarshaller.Instance;options.ResponseUnmarshaller = GetConnectionResponseUnmarshaller.Instance;return Invoke<GetConnectionResponse>(request, options);}
// Original:
public String toString() {return a+".."+b;}

// Translation:
public override string ToString(){return a + ".." + b;}
// Original:
public AddNoteCommand notesAdd() {return new AddNoteCommand(repo);}

// Translation:
public virtual AddNoteCommand NotesAdd(){return new AddNoteCommand(repo);}
// Original:
public static void fill(short[] array, int start, int end, short value) {Arrays.checkStartAndEnd(array.length, start, end);for (int i = start; i < end; i++) {array[i] = value;}}

// Translation:
public static void fill(short[] array, int start, int end, short value){java.util.Arrays.checkStartAndEnd(array.Length, start, end);{for (int i = start; i < end; i++){array[i] = value;}}}
// Original:
public boolean equals(Object obj) {if (obj == this) {return true;}else if (!(obj instanceof LexerIndexedCustomAction)) {return false;}LexerIndexedCustomAction other = (LexerIndexedCustomAction)obj;return offset == other.offset&& action.equals(other.action);}

// Translation:
public override bool Equals(object obj){if (obj == this){return true;}else{if (!(obj is Antlr4.Runtime.Atn.LexerIndexedCustomAction)){return false;}}Antlr4.Runtime.Atn.LexerIndexedCustomAction other = (Antlr4.Runtime.Atn.LexerIndexedCustomAction)obj;return offset == other.offset && action.Equals(other.action);}
// Original:
public DeleteNamespaceAuthorizationRequest() {super("cr", "2016-06-07", "DeleteNamespaceAuthorization", "cr");setUriPattern("/namespace/[Namespace]/authorizations/[AuthorizeId]");setMethod(MethodType.DELETE);}

// Translation:
public DeleteNamespaceAuthorizationRequest(): base("cr", "2016-06-07", "DeleteNamespaceAuthorization", "cr", "openAPI"){UriPattern = "/namespace/[Namespace]/authorizations/[AuthorizeId]";Method = MethodType.DELETE;}
// Original:
public static final int author(byte[] b, int ptr) {final int sz = b.length;if (ptr == 0)ptr += 46; while (ptr < sz && b[ptr] == 'p')ptr += 48; return match(b, ptr, author);}

// Translation:
public static int Author(byte[] b, int ptr){int sz = b.Length;if (ptr == 0){ptr += 46;}while (ptr < sz && b[ptr] == 'p'){ptr += 48;}return Match(b, ptr, ObjectChecker.author);}
// Original:
public DescribeHostsResult describeHosts(DescribeHostsRequest request) {request = beforeClientExecution(request);return executeDescribeHosts(request);}

// Translation:
public virtual DescribeHostsResponse DescribeHosts(DescribeHostsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeHostsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeHostsResponseUnmarshaller.Instance;return Invoke<DescribeHostsResponse>(request, options);}
// Original:
public void reset(byte[] bytes) {reset(bytes, 0, bytes.length);}

// Translation:
public void Reset(byte[] bytes){Reset(bytes, 0, bytes.Length);}
// Original:
public OpenNLPChunkerFilterFactory(Map<String,String> args) {super(args);chunkerModelFile = get(args, CHUNKER_MODEL);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public OpenNLPChunkerFilterFactory(IDictionary<string, string> args): base(args){chunkerModelFile = Get(args, CHUNKER_MODEL);if (args.Any()){throw new ArgumentException("Unknown parameters: " + args);}}
// Original:
public String toString() {StringBuilder r = new StringBuilder();r.append("Ref["); r.append(getName());r.append('=');r.append(ObjectId.toString(getObjectId()));r.append('(');r.append(updateIndex); r.append(")]"); return r.toString();}

// Translation:
public override string ToString(){StringBuilder r = new StringBuilder();r.Append("Ref[");r.Append(GetName());r.Append('=');r.Append(ObjectId.ToString(GetObjectId()));r.Append(']');return r.ToString();}
// Original:
public StartStreamEncryptionResult startStreamEncryption(StartStreamEncryptionRequest request) {request = beforeClientExecution(request);return executeStartStreamEncryption(request);}

// Translation:
public virtual StartStreamEncryptionResponse StartStreamEncryption(StartStreamEncryptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartStreamEncryptionRequestMarshaller.Instance;options.ResponseUnmarshaller = StartStreamEncryptionResponseUnmarshaller.Instance;return Invoke<StartStreamEncryptionResponse>(request, options);}
// Original:
public DeleteCloudFrontOriginAccessIdentityRequest(String id, String ifMatch) {setId(id);setIfMatch(ifMatch);}

// Translation:
public DeleteCloudFrontOriginAccessIdentityRequest(string id, string ifMatch){_id = id;_ifMatch = ifMatch;}
// Original:
public int getWidth() {return mImage.getWidth();}

// Translation:
public virtual int getWidth(){return mBitmap.getWidth();}
// Original:
public List<String> getUntrackedFolders() {LinkedList<String> ret = new LinkedList<>(untrackedFolders);if (!untrackedParentFolders.isEmpty()) {String toBeAdded = untrackedParentFolders.getLast();while (!ret.isEmpty() && ret.getLast().startsWith(toBeAdded))ret.removeLast();ret.addLast(toBeAdded);}return ret;}

// Translation:
public virtual IList<string> GetUntrackedFolders(){List<string> ret = new List<string>(untrackedFolders);if (!untrackedParentFolders.IsEmpty()){string toBeAdded = untrackedParentFolders.GetLast();while (!ret.IsEmpty() && ret.GetLast().StartsWith(toBeAdded)){ret.RemoveLast();}ret.AddLast(toBeAdded);}return ret;}
// Original:
public CredentialsProviderUserInfo(Session session,CredentialsProvider credentialsProvider) {this.uri = createURI(session);this.provider = credentialsProvider;}

// Translation:
public CredentialsProviderUserInfo(Session session, CredentialsProvider credentialsProvider){this.uri = CreateURI(session);this.provider = credentialsProvider;}
// Original:
public String toString() {return "[SELECTION]\n" +"    .pane            = " + HexDump.byteToHex(getPane()) + "\n" +"    .activecellrow   = " + HexDump.shortToHex(getActiveCellRow()) + "\n" +"    .activecellcol   = " + HexDump.shortToHex(getActiveCellCol()) + "\n" +"    .activecellref   = " + HexDump.shortToHex(getActiveCellRef()) + "\n" +"    .numrefs         = " + HexDump.shortToHex(field_6_refs.length) + "\n" +"[/SELECTION]\n";}

// Translation:
public override String ToString(){StringBuilder buffer = new StringBuilder();buffer.Append("[SELECTION]\n");buffer.Append("    .pane            = ").Append(StringUtil.ToHexString(Pane)).Append("\n");buffer.Append("    .activecellrow   = ").Append(StringUtil.ToHexString(ActiveCellRow)).Append("\n");buffer.Append("    .activecellcol   = ").Append(StringUtil.ToHexString(ActiveCellCol)).Append("\n");buffer.Append("    .activecellref   = ").Append(StringUtil.ToHexString(ActiveCellRef)).Append("\n");buffer.Append("    .numrefs         = ").Append(StringUtil.ToHexString(field_6_refs.Length)).Append("\n");buffer.Append("[/SELECTION]\n");return buffer.ToString();}
// Original:
public static boolean isCellInternalDateFormatted(Cell cell) {if (cell == null) {return false;}boolean bDate = false;double d = cell.getNumericCellValue();if ( DateUtil.isValidExcelDate(d) ) {CellStyle style = cell.getCellStyle();int i = style.getDataFormat();bDate = isInternalDateFormat(i);}return bDate;}

// Translation:
public static bool IsCellInternalDateFormatted(ICell cell){if (cell == null) return false;bool bDate = false;double d = cell.NumericCellValue;if (DateUtil.IsValidExcelDate(d)){ICellStyle style = cell.CellStyle;int i = style.DataFormat;bDate = IsInternalDateFormat(i);}return bDate;}
// Original:
public static String getSegmentsFile(List<String> files, boolean allowEmpty) {if (files.isEmpty()) {if (allowEmpty) {return null;} else {throw new IllegalStateException("empty list of files not allowed");}}String segmentsFile = files.remove(files.size() - 1);if (!segmentsFile.startsWith(IndexFileNames.SEGMENTS)) {throw new IllegalStateException("last file to copy+sync must be segments_N but got " + segmentsFile+ "; check your Revision implementation!");}return segmentsFile;}

// Translation:
public static string GetSegmentsFile(IList<string> files, bool allowEmpty){if (!files.Any()){if (allowEmpty)return null;throw new InvalidOperationException("empty list of files not allowed");}string segmentsFile = files.Last();files.RemoveAt(files.Count - 1);if (!segmentsFile.StartsWith(IndexFileNames.SEGMENTS, StringComparison.Ordinal) || segmentsFile.Equals(IndexFileNames.SEGMENTS_GEN, StringComparison.Ordinal)){throw new InvalidOperationException(string.Format("last file to copy+sync must be segments_N but got {0}; check your Revision implementation!", segmentsFile));}return segmentsFile;}
// Original:
public static boolean hasMultibyte(String value) {if (value == null) {return false;}for (char c : value.toCharArray()) {if (c > 0xFF) {return true;}}return false;}

// Translation:
public static bool HasMultibyte(String value){if (value == null) return false;for (int i = 0; i < value.Length; i++){char c = value[i];if (c > 0xFF) return true;}return false;}
// Original:
public static ObjectId fromString(String str) {if (str.length() != Constants.OBJECT_ID_STRING_LENGTH) {throw new InvalidObjectIdException(str);}return fromHexString(Constants.encodeASCII(str), 0);}

// Translation:
public static NGit.ObjectId FromString(string str){if (str.Length != Constants.OBJECT_ID_STRING_LENGTH){throw new ArgumentException("Invalid id: " + str);}return FromHexString(Constants.EncodeASCII(str), 0);}
// Original:
public void reset() throws IOException {throw new IOException();}

// Translation:
public override void reset(){throw new System.IO.IOException();}
// Original:
public GetReservedInstancesExchangeQuoteResult getReservedInstancesExchangeQuote(GetReservedInstancesExchangeQuoteRequest request) {request = beforeClientExecution(request);return executeGetReservedInstancesExchangeQuote(request);}

// Translation:
public virtual GetReservedInstancesExchangeQuoteResponse GetReservedInstancesExchangeQuote(GetReservedInstancesExchangeQuoteRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetReservedInstancesExchangeQuoteRequestMarshaller.Instance;options.ResponseUnmarshaller = GetReservedInstancesExchangeQuoteResponseUnmarshaller.Instance;return Invoke<GetReservedInstancesExchangeQuoteResponse>(request, options);}
// Original:
public IntBuffer put(int c) {throw new ReadOnlyBufferException();}

// Translation:
public override java.nio.IntBuffer put(int c){throw new java.nio.ReadOnlyBufferException();}
// Original:
public GetFolderPathResult getFolderPath(GetFolderPathRequest request) {request = beforeClientExecution(request);return executeGetFolderPath(request);}

// Translation:
public virtual GetFolderPathResponse GetFolderPath(GetFolderPathRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetFolderPathRequestMarshaller.Instance;options.ResponseUnmarshaller = GetFolderPathResponseUnmarshaller.Instance;return Invoke<GetFolderPathResponse>(request, options);}
// Original:
public DeleteDirectConnectGatewayAssociationResult deleteDirectConnectGatewayAssociation(DeleteDirectConnectGatewayAssociationRequest request) {request = beforeClientExecution(request);return executeDeleteDirectConnectGatewayAssociation(request);}

// Translation:
public virtual DeleteDirectConnectGatewayAssociationResponse DeleteDirectConnectGatewayAssociation(DeleteDirectConnectGatewayAssociationRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteDirectConnectGatewayAssociationRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteDirectConnectGatewayAssociationResponseUnmarshaller.Instance;return Invoke<DeleteDirectConnectGatewayAssociationResponse>(request, options);}
// Original:
public ByteBuffer putDouble(double value) {return putLong(Double.doubleToRawLongBits(value));}

// Translation:
public override java.nio.ByteBuffer putDouble(double value){return putLong(Sharpen.Util.DoubleToRawLongBits(value));}
// Original:
public SearchContactsResult searchContacts(SearchContactsRequest request) {request = beforeClientExecution(request);return executeSearchContacts(request);}

// Translation:
public virtual SearchContactsResponse SearchContacts(SearchContactsRequest request){var options = new InvokeOptions();options.RequestMarshaller = SearchContactsRequestMarshaller.Instance;options.ResponseUnmarshaller = SearchContactsResponseUnmarshaller.Instance;return Invoke<SearchContactsResponse>(request, options);}
// Original:
@Override public boolean isEmpty() {return size == 0;}

// Translation:
public override bool isEmpty(){return _size == 0;}
// Original:
public CreatePartnerEventSourceResult createPartnerEventSource(CreatePartnerEventSourceRequest request) {request = beforeClientExecution(request);return executeCreatePartnerEventSource(request);}

// Translation:
public virtual CreatePartnerEventSourceResponse CreatePartnerEventSource(CreatePartnerEventSourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePartnerEventSourceRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePartnerEventSourceResponseUnmarshaller.Instance;return Invoke<CreatePartnerEventSourceResponse>(request, options);}
// Original:
public CreateNamespaceAuthorizationRequest() {super("cr", "2016-06-07", "CreateNamespaceAuthorization", "cr");setUriPattern("/namespace/[Namespace]/authorizations");setMethod(MethodType.PUT);}

// Translation:
public CreateNamespaceAuthorizationRequest(): base("cr", "2016-06-07", "CreateNamespaceAuthorization", "cr", "openAPI"){UriPattern = "/namespace/[Namespace]/authorizations";Method = MethodType.PUT;}
// Original:
public URIish setPass(String n) {final URIish r = new URIish(this);r.pass = n;return r;}

// Translation:
public virtual NGit.Transport.URIish SetPass(string n){NGit.Transport.URIish r = new NGit.Transport.URIish(this);r.pass = n;return r;}
// Original:
public void execute(Lexer lexer) {lexer.pushMode(mode);}

// Translation:
public void Execute(Lexer lexer){lexer.PushMode(mode);}
// Original:
public CreateModelVersionResult createModelVersion(CreateModelVersionRequest request) {request = beforeClientExecution(request);return executeCreateModelVersion(request);}

// Translation:
public virtual CreateModelVersionResponse CreateModelVersion(CreateModelVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateModelVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateModelVersionResponseUnmarshaller.Instance;return Invoke<CreateModelVersionResponse>(request, options);}
// Original:
public UpdateServicePrimaryTaskSetResult updateServicePrimaryTaskSet(UpdateServicePrimaryTaskSetRequest request) {request = beforeClientExecution(request);return executeUpdateServicePrimaryTaskSet(request);}

// Translation:
public virtual UpdateServicePrimaryTaskSetResponse UpdateServicePrimaryTaskSet(UpdateServicePrimaryTaskSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateServicePrimaryTaskSetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateServicePrimaryTaskSetResponseUnmarshaller.Instance;return Invoke<UpdateServicePrimaryTaskSetResponse>(request, options);}
// Original:
public LinearRegressionFunction(FUNCTION function) {this.function = function;}

// Translation:
public LinearRegressionFunction(FUNCTION function){this.function = function;}
// Original:
public ATNConfig(ATNConfig old) { this.state = old.state;this.alt = old.alt;this.context = old.context;this.semanticContext = old.semanticContext;this.reachesIntoOuterContext = old.reachesIntoOuterContext;}

// Translation:
public ATNConfig(ATNConfig old){ this.state = old.state;this.alt = old.alt;this.context = old.context;this.semanticContext = old.semanticContext;this.reachesIntoOuterContext = old.reachesIntoOuterContext;}
// Original:
public DescribeEntitiesDetectionJobResult describeEntitiesDetectionJob(DescribeEntitiesDetectionJobRequest request) {request = beforeClientExecution(request);return executeDescribeEntitiesDetectionJob(request);}

// Translation:
public virtual DescribeEntitiesDetectionJobResponse DescribeEntitiesDetectionJob(DescribeEntitiesDetectionJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeEntitiesDetectionJobRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeEntitiesDetectionJobResponseUnmarshaller.Instance;return Invoke<DescribeEntitiesDetectionJobResponse>(request, options);}
// Original:
public AssociateDhcpOptionsRequest(String vpcId) {setVpcId(vpcId);}

// Translation:
public AssociateDhcpOptionsRequest(string vpcId){_vpcId = vpcId;}
// Original:
public ListChangedBlocksResult listChangedBlocks(ListChangedBlocksRequest request) {request = beforeClientExecution(request);return executeListChangedBlocks(request);}

// Translation:
public virtual ListChangedBlocksResponse ListChangedBlocks(ListChangedBlocksRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListChangedBlocksRequestMarshaller.Instance;options.ResponseUnmarshaller = ListChangedBlocksResponseUnmarshaller.Instance;return Invoke<ListChangedBlocksResponse>(request, options);}
// Original:
public boolean removeFirstOccurrence(Object o) {return removeFirstOccurrenceImpl(o);}

// Translation:
public virtual bool removeFirstOccurrence(object o){return removeFirstOccurrenceImpl(o);}
// Original:
public ArrayList<PerfTask> extractTasks() {ArrayList<PerfTask> res = new ArrayList<>();extractTasks(res, sequence);return res;}

// Translation:
public virtual IList<PerfTask> ExtractTasks(){List<PerfTask> res = new List<PerfTask>();ExtractTasks(res, sequence);return res;}
// Original:
public FacetsCollector(boolean keepScores) {this.keepScores = keepScores;}

// Translation:
public FacetsCollector(bool keepScores){this.keepScores = keepScores;}
// Original:
public UpdateNodegroupVersionResult updateNodegroupVersion(UpdateNodegroupVersionRequest request) {request = beforeClientExecution(request);return executeUpdateNodegroupVersion(request);}

// Translation:
public virtual UpdateNodegroupVersionResponse UpdateNodegroupVersion(UpdateNodegroupVersionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateNodegroupVersionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateNodegroupVersionResponseUnmarshaller.Instance;return Invoke<UpdateNodegroupVersionResponse>(request, options);}
// Original:
public DeleteAttributesRequest(String domainName, String itemName) {setDomainName(domainName);setItemName(itemName);}

// Translation:
public DeleteAttributesRequest(string domainName, string itemName){_domainName = domainName;_itemName = itemName;}
// Original:
public void clearDFA() {throw new UnsupportedOperationException("This ATN simulator does not support clearing the DFA.");}

// Translation:
public virtual void ClearDFA(){throw new Exception("This ATN simulator does not support clearing the DFA.");}
// Original:
public Field[] createIndexableFields(Shape shape) {if (shape instanceof Point)return createIndexableFields((Point) shape);throw new UnsupportedOperationException("Can only index Point, not " + shape);}

// Translation:
public override Field[] CreateIndexableFields(IShape shape){var point = shape as IPoint;if (point != null)return CreateIndexableFields(point);throw new NotSupportedException("Can only index IPoint, not " + shape);}
// Original:
public void untagResource(UntagResourceRequest request) {request = beforeClientExecution(request);executeUntagResource(request);}

// Translation:
public virtual UntagResourceResponse UntagResource(UntagResourceRequest request){var options = new InvokeOptions();options.RequestMarshaller = UntagResourceRequestMarshaller.Instance;options.ResponseUnmarshaller = UntagResourceResponseUnmarshaller.Instance;return Invoke<UntagResourceResponse>(request, options);}