yijunyu/c-to-rust huggingface dataset:
// Original:
public MoveAlbumPhotosRequest() {super("CloudPhoto", "2017-07-11", "MoveAlbumPhotos", "cloudphoto");setProtocol(ProtocolType.HTTPS);}

// Translation:
public MoveAlbumPhotosRequest(): base("CloudPhoto", "2017-07-11", "MoveAlbumPhotos", "cloudphoto", "openAPI"){Protocol = ProtocolType.HTTPS;}
// Original:
public UpdateStackSetResult updateStackSet(UpdateStackSetRequest request) {request = beforeClientExecution(request);return executeUpdateStackSet(request);}

// Translation:
public virtual UpdateStackSetResponse UpdateStackSet(UpdateStackSetRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateStackSetRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateStackSetResponseUnmarshaller.Instance;return Invoke<UpdateStackSetResponse>(request, options);}
// Original:
public static double acosh(double d) {return Math.log(Math.sqrt(Math.pow(d, 2) - 1) + d);}

// Translation:
public static double Acosh(double d){return Math.Log(Math.Sqrt(Math.Pow(d, 2) - 1) + d);}
// Original:
public int stem(char s[], int len) {for (int i = 0; i < len; i++)switch(s[i]) {case 'ä':case 'à':case 'á':case 'â': s[i] = 'a'; break;case 'ö':case 'ò':case 'ó':case 'ô': s[i] = 'o'; break;case 'ï':case 'ì':case 'í':case 'î': s[i] = 'i'; break;case 'ü':case 'ù':case 'ú':case 'û': s[i] = 'u'; break;}len = step1(s, len);return step2(s, len);}

// Translation:
public virtual int Stem(char[] s, int len){for (int i = 0; i < len; i++){switch (s[i]){case 'ä':case 'à':case 'á':case 'â':s[i] = 'a';break;case 'ö':case 'ò':case 'ó':case 'ô':s[i] = 'o';break;case 'ï':case 'ì':case 'í':case 'î':s[i] = 'i';break;case 'ü':case 'ù':case 'ú':case 'û':s[i] = 'u';break;}}len = Step1(s, len);return Step2(s, len);}
// Original:
public CreateProposalResult createProposal(CreateProposalRequest request) {request = beforeClientExecution(request);return executeCreateProposal(request);}

// Translation:
public virtual CreateProposalResponse CreateProposal(CreateProposalRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateProposalRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateProposalResponseUnmarshaller.Instance;return Invoke<CreateProposalResponse>(request, options);}
// Original:
public boolean didFetchIncludeTags() {return false;}

// Translation:
public virtual bool DidFetchIncludeTags(){return false;}
// Original:
public RevCommit peek() {return head != null ? head.commit : null;}

// Translation:
public virtual RevCommit Peek(){return head != null ? head.commit : null;}
// Original:
public HSSFBorderFormatting getBorderFormatting() {return getBorderFormatting(false);}

// Translation:
public IBorderFormatting GetBorderFormatting(){return GetBorderFormatting(false);}
// Original:
public DeletedArea3DPtg(int externSheetIndex) {field_1_index_extern_sheet = externSheetIndex;unused1 = 0;unused2 = 0;}

// Translation:
public DeletedArea3DPtg(int externSheetIndex){field_1_index_extern_sheet = externSheetIndex;unused1 = 0;unused2 = 0;}
// Original:
public SheetRecordCollector() {_totalSize = 0;_list = new ArrayList<>(128);}

// Translation:
public SheetRecordCollector(){_totalSize = 0;_list = new ArrayList(128);}
// Original:
public RemovePermissionResult removePermission(RemovePermissionRequest request) {request = beforeClientExecution(request);return executeRemovePermission(request);}

// Translation:
public virtual RemovePermissionResponse RemovePermission(RemovePermissionRequest request){var options = new InvokeOptions();options.RequestMarshaller = RemovePermissionRequestMarshaller.Instance;options.ResponseUnmarshaller = RemovePermissionResponseUnmarshaller.Instance;return Invoke<RemovePermissionResponse>(request, options);}
// Original:
public Cluster modifyClusterIamRoles(ModifyClusterIamRolesRequest request) {request = beforeClientExecution(request);return executeModifyClusterIamRoles(request);}

// Translation:
public virtual ModifyClusterIamRolesResponse ModifyClusterIamRoles(ModifyClusterIamRolesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ModifyClusterIamRolesRequestMarshaller.Instance;options.ResponseUnmarshaller = ModifyClusterIamRolesResponseUnmarshaller.Instance;return Invoke<ModifyClusterIamRolesResponse>(request, options);}
// Original:
public AreaFormatRecord(RecordInputStream in) {field_1_foregroundColor        = in.readInt();field_2_backgroundColor        = in.readInt();field_3_pattern                = in.readShort();field_4_formatFlags            = in.readShort();field_5_forecolorIndex         = in.readShort();field_6_backcolorIndex         = in.readShort();}

// Translation:
public AreaFormatRecord(RecordInputStream in1){field_1_foregroundColor = in1.ReadInt();field_2_backgroundColor = in1.ReadInt();field_3_pattern = in1.ReadShort();field_4_formatFlags = in1.ReadShort();field_5_forecolorIndex = in1.ReadShort();field_6_backcolorIndex = in1.ReadShort();}
// Original:
public int available() {return _lei.available();}

// Translation:
public int Available(){return _lei.Available();}
// Original:
public final String toString() {return toString("");}

// Translation:
public override string ToString(){return ToString("");}
// Original:
public short setShort(final short holder){return ( short ) set(holder);}

// Translation:
public short SetShort(short holder){return (short)this.Set(holder);}
// Original:
public synchronized void setFlushPending(ThreadState perThread) {assert !perThread.flushPending;if (perThread.dwpt.getNumDocsInRAM() > 0) {perThread.flushPending = true; final long bytes = perThread.bytesUsed;flushBytes += bytes;activeBytes -= bytes;numPending++; assert assertMemory();} }

// Translation:
public void SetFlushPending(ThreadState perThread){lock (this){Debug.Assert(!perThread.flushPending);if (perThread.dwpt.NumDocsInRAM > 0){perThread.flushPending = true; long bytes = perThread.bytesUsed;flushBytes += bytes;activeBytes -= bytes;numPending++; Debug.Assert(AssertMemory());} }}
// Original:
public StringBuilder insert(int offset, char[] ch) {insert0(offset, ch);return this;}

// Translation:
public java.lang.StringBuilder insert(int offset, char[] ch){insert0(offset, ch);return this;}
// Original:
public StoredField(String name, double value) {super(name, TYPE);fieldsData = value;}

// Translation:
public StoredField(string name, double value): base(name, TYPE){FieldsData = new Double(value);}
// Original:
public String getName() {return String.format(Locale.ROOT, "Jelinek-Mercer(%f)", getLambda());}

// Translation:
public override string GetName(){return "Jelinek-Mercer(" + Number.ToString(Lambda) + ")";}
// Original:
public ReleaseAddressRequest(String publicIp) {setPublicIp(publicIp);}

// Translation:
public ReleaseAddressRequest(string publicIp){_publicIp = publicIp;}
// Original:
public DeleteKeyPairResult deleteKeyPair(DeleteKeyPairRequest request) {request = beforeClientExecution(request);return executeDeleteKeyPair(request);}

// Translation:
public virtual DeleteKeyPairResponse DeleteKeyPair(DeleteKeyPairRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteKeyPairRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteKeyPairResponseUnmarshaller.Instance;return Invoke<DeleteKeyPairResponse>(request, options);}
// Original:
public byte[] getColor(int byteIndex) {int i = byteIndex - FIRST_COLOR_INDEX;if (i < 0 || i >= _colors.size()) {return null;}return _colors.get(i).getTriplet();}

// Translation:
public byte[] GetColor(short byteIndex){int i = byteIndex - FIRST_COLOR_INDEX;if (i < 0 || i >= field_2_colors.Count){return null;}PColor color = (PColor)field_2_colors[i];return new byte[] { color._red, color._green, color._blue };}
// Original:
public int indexOfValue(E value) {if (mGarbage) {gc();}for (int i = 0; i < mSize; i++)if (mValues[i] == value)return i;return -1;}

// Translation:
public virtual int indexOfValue(E value){if (mGarbage){gc();}{for (int i = 0; i < mSize; i++){if (Sharpen.Util.Equals(value, mValues[i])){return i;}}}return -1;}
// Original:
public URIish setScheme(String n) {final URIish r = new URIish(this);r.scheme = n;return r;}

// Translation:
public virtual NGit.Transport.URIish SetScheme(string n){NGit.Transport.URIish r = new NGit.Transport.URIish(this);r.scheme = n;return r;}
// Original:
public void print(char[] charArray) {print(new String(charArray, 0, charArray.length));}

// Translation:
public virtual void print(char[] charArray){print(new string(charArray, 0, charArray.Length));}
// Original:
public CommonToken(int type, String text) {this.type = type;this.channel = DEFAULT_CHANNEL;this.text = text;this.source = EMPTY_SOURCE;}

// Translation:
public CommonToken(int type, string text){this._type = type;this._channel = TokenConstants.DefaultChannel;this._text = text;this.source = EmptySource;}
// Original:
public final String toString() { return field + ":" + text(); }

// Translation:
public override string ToString(){return Field + ":" + Text();}
// Original:
public LongBuffer compact() {if (byteBuffer.isReadOnly()) {throw new ReadOnlyBufferException();}byteBuffer.limit(limit * SizeOf.LONG);byteBuffer.position(position * SizeOf.LONG);byteBuffer.compact();byteBuffer.clear();position = limit - position;limit = capacity;mark = UNSET_MARK;return this;}

// Translation:
public override java.nio.LongBuffer compact(){if (byteBuffer.isReadOnly()){throw new java.nio.ReadOnlyBufferException();}byteBuffer.limit(_limit * libcore.io.SizeOf.LONG);byteBuffer.position(_position * libcore.io.SizeOf.LONG);byteBuffer.compact();byteBuffer.clear();_position = _limit - _position;_limit = _capacity;_mark = UNSET_MARK;return this;}
// Original:
public ATNSimulator(ATN atn,PredictionContextCache sharedContextCache){this.atn = atn;this.sharedContextCache = sharedContextCache;}

// Translation:
public ATNSimulator(ATN atn, PredictionContextCache sharedContextCache){this.atn = atn;this.sharedContextCache = sharedContextCache;}
// Original:
public CachedOrdinalsReader(OrdinalsReader source) {this.source = source;}

// Translation:
public CachedOrdinalsReader(OrdinalsReader source){this.source = source;}
// Original:
public static CompareResult valueOf(boolean matches) {if(matches) {return EQUAL ;}return LESS_THAN;}

// Translation:
public static CompareResult ValueOf(bool matches){if (matches){return Equal;}return LessThan;}
// Original:
public void serialize(LittleEndianOutput out) {out.writeShort(getVersion());out.writeShort(getType());out.writeShort(getBuild());out.writeShort(getBuildYear());out.writeInt(getHistoryBitMask());out.writeInt(getRequiredVersion());}

// Translation:
public override void Serialize(ILittleEndianOutput out1){out1.WriteShort(Version);out1.WriteShort((int) Type);out1.WriteShort(Build);out1.WriteShort(BuildYear);out1.WriteInt(HistoryBitMask);out1.WriteInt(RequiredVersion);}
// Original:
public File getAbsoluteFile() {return new File(getAbsolutePath());}

// Translation:
public java.io.File getAbsoluteFile(){return new java.io.File(getAbsolutePath());}
// Original:
public DescribeTemplatePermissionsResult describeTemplatePermissions(DescribeTemplatePermissionsRequest request) {request = beforeClientExecution(request);return executeDescribeTemplatePermissions(request);}

// Translation:
public virtual DescribeTemplatePermissionsResponse DescribeTemplatePermissions(DescribeTemplatePermissionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeTemplatePermissionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeTemplatePermissionsResponseUnmarshaller.Instance;return Invoke<DescribeTemplatePermissionsResponse>(request, options);}
// Original:
public WorkflowExecutionCount countOpenWorkflowExecutions(CountOpenWorkflowExecutionsRequest request) {request = beforeClientExecution(request);return executeCountOpenWorkflowExecutions(request);}

// Translation:
public virtual CountOpenWorkflowExecutionsResponse CountOpenWorkflowExecutions(CountOpenWorkflowExecutionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = CountOpenWorkflowExecutionsRequestMarshaller.Instance;options.ResponseUnmarshaller = CountOpenWorkflowExecutionsResponseUnmarshaller.Instance;return Invoke<CountOpenWorkflowExecutionsResponse>(request, options);}
// Original:
public DescribeAccountLimitsResult describeAccountLimits() {return describeAccountLimits(new DescribeAccountLimitsRequest());}

// Translation:
public virtual DescribeAccountLimitsResponse DescribeAccountLimits(){return DescribeAccountLimits(new DescribeAccountLimitsRequest());}
// Original:
public Object get(CharSequence key) {if (fst == null) {return null;}Arc<Long> arc = new Arc<>();Long result = null;try {result = lookupPrefix(new BytesRef(key), arc);} catch (IOException bogus) { throw new RuntimeException(bogus); }if (result == null || !arc.isFinal()) {return null;} else {return Integer.valueOf(decodeWeight(result + arc.nextFinalOutput()));}}

// Translation:
public virtual object Get(string key){if (fst == null){return null;}FST.Arc<long?> arc = new FST.Arc<long?>();long? result = null;try{result = LookupPrefix(new BytesRef(key), arc);}catch (IOException bogus){throw new Exception(bogus.ToString(), bogus);}if (result == null || !arc.IsFinal){return null;}else{return DecodeWeight(result.GetValueOrDefault() + arc.NextFinalOutput.GetValueOrDefault());}}
// Original:
public CreateGameServerGroupResult createGameServerGroup(CreateGameServerGroupRequest request) {request = beforeClientExecution(request);return executeCreateGameServerGroup(request);}

// Translation:
public virtual CreateGameServerGroupResponse CreateGameServerGroup(CreateGameServerGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateGameServerGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateGameServerGroupResponseUnmarshaller.Instance;return Invoke<CreateGameServerGroupResponse>(request, options);}
// Original:
public static boolean isInternalDateFormat(int format) {switch(format) {case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x2d:case 0x2e:case 0x2f:return true;}return false;}

// Translation:
public static bool IsInternalDateFormat(int format){bool retval = false;switch (format){case 0x0e:case 0x0f:case 0x10:case 0x11:case 0x12:case 0x13:case 0x14:case 0x15:case 0x16:case 0x2d:case 0x2e:case 0x2f:retval = true;break;default:retval = false;break;}return retval;}
// Original:
public PackFile getPackFile() {return newPack;}

// Translation:
public virtual PackFile GetPackFile(){return newPack;}
// Original:
public CreateInternetGatewayResult createInternetGateway() {return createInternetGateway(new CreateInternetGatewayRequest());}

// Translation:
public virtual CreateInternetGatewayResponse CreateInternetGateway(){return CreateInternetGateway(new CreateInternetGatewayRequest());}
// Original:
public void drawPolyline(int[] xPoints, int[] yPoints,int nPoints){if (logger.check( POILogger.WARN ))logger.log(POILogger.WARN,"drawPolyline not supported");}

// Translation:
public void DrawPolyline(int[] xPoints, int[] yPoints,int nPoints){if (Logger.Check(POILogger.WARN))Logger.Log(POILogger.WARN, "DrawPolyline not supported");}
// Original:
public void close() {unpackedObjectCache.clear();final PackList packs = packList.get();if (packs != NO_PACKS && packList.compareAndSet(packs, NO_PACKS)) {for (PackFile p : packs.packs)p.close();}AlternateHandle[] alt = alternates.get();if (alt != null && alternates.compareAndSet(alt, null)) {for(AlternateHandle od : alt)od.close();}}

// Translation:
public override void Close(){unpackedObjectCache.Clear();ObjectDirectory.PackList packs = packList.Get();packList.Set(NO_PACKS);foreach (PackFile p in packs.packs){p.Close();}FileObjectDatabase.AlternateHandle[] alt = alternates.Get();if (alt != null){alternates.Set(null);foreach (FileObjectDatabase.AlternateHandle od in alt){od.Close();}}}
// Original:
public List<Token> getHiddenTokensToRight(int tokenIndex, int channel) {lazyInit();if ( tokenIndex<0 || tokenIndex>=tokens.size() ) {throw new IndexOutOfBoundsException(tokenIndex+" not in 0.."+(tokens.size()-1));}int nextOnChannel =nextTokenOnChannel(tokenIndex + 1, Lexer.DEFAULT_TOKEN_CHANNEL);int to;int from = tokenIndex+1;if ( nextOnChannel == -1 ) to = size()-1;else to = nextOnChannel;return filterForChannel(from, to, channel);}

// Translation:
public virtual IList<IToken> GetHiddenTokensToRight(int tokenIndex, int channel){LazyInit();if (tokenIndex < 0 || tokenIndex >= tokens.Count){throw new ArgumentOutOfRangeException(tokenIndex + " not in 0.." + (tokens.Count - 1));}int nextOnChannel = NextTokenOnChannel(tokenIndex + 1, Lexer.DefaultTokenChannel);int to;int from = tokenIndex + 1;if (nextOnChannel == -1){to = Size - 1;}else{to = nextOnChannel;}return FilterForChannel(from, to, channel);}
// Original:
public int size() {return Hashtable.this.size();}

// Translation:
public override int size(){return this._enclosing.size();}
// Original:
public CustomAvailabilityZone deleteCustomAvailabilityZone(DeleteCustomAvailabilityZoneRequest request) {request = beforeClientExecution(request);return executeDeleteCustomAvailabilityZone(request);}

// Translation:
public virtual DeleteCustomAvailabilityZoneResponse DeleteCustomAvailabilityZone(DeleteCustomAvailabilityZoneRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteCustomAvailabilityZoneRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteCustomAvailabilityZoneResponseUnmarshaller.Instance;return Invoke<DeleteCustomAvailabilityZoneResponse>(request, options);}
// Original:
public BatchUnsuspendUserResult batchUnsuspendUser(BatchUnsuspendUserRequest request) {request = beforeClientExecution(request);return executeBatchUnsuspendUser(request);}

// Translation:
public virtual BatchUnsuspendUserResponse BatchUnsuspendUser(BatchUnsuspendUserRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchUnsuspendUserRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchUnsuspendUserResponseUnmarshaller.Instance;return Invoke<BatchUnsuspendUserResponse>(request, options);}
// Original:
public DeleteAccountSettingResult deleteAccountSetting(DeleteAccountSettingRequest request) {request = beforeClientExecution(request);return executeDeleteAccountSetting(request);}

// Translation:
public virtual DeleteAccountSettingResponse DeleteAccountSetting(DeleteAccountSettingRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteAccountSettingRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteAccountSettingResponseUnmarshaller.Instance;return Invoke<DeleteAccountSettingResponse>(request, options);}
// Original:
public static SemanticContext or(SemanticContext a, SemanticContext b) {if ( a == null ) return b;if ( b == null ) return a;if ( a == NONE || b == NONE ) return NONE;OR result = new OR(a, b);if (result.opnds.length == 1) {return result.opnds[0];}return result;}

// Translation:
public OR(SemanticContext a, SemanticContext b){HashSet<SemanticContext> operands = new HashSet<SemanticContext>();if (a is SemanticContext.OR){operands.UnionWith(((OR)a).opnds);}else{operands.Add(a);}if (b is SemanticContext.OR){operands.UnionWith(((OR)b).opnds);}else{operands.Add(b);}IList<SemanticContext.PrecedencePredicate> precedencePredicates = FilterPrecedencePredicates(operands);if (precedencePredicates.Count > 0){SemanticContext.PrecedencePredicate reduced = precedencePredicates.Max();operands.Add(reduced);}this.opnds = operands.ToArray();}
// Original:
public ListHumanLoopsResult listHumanLoops(ListHumanLoopsRequest request) {request = beforeClientExecution(request);return executeListHumanLoops(request);}

// Translation:
public virtual ListHumanLoopsResponse ListHumanLoops(ListHumanLoopsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListHumanLoopsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListHumanLoopsResponseUnmarshaller.Instance;return Invoke<ListHumanLoopsResponse>(request, options);}
// Original:
public ValueEval evaluate(ValueEval[] args, int srcCellRow, int srcCellCol) {int maxN = args.length;if(maxN < 1) {return ErrorEval.VALUE_INVALID;}ValueEval firstArg = args[0];try {if(firstArg instanceof NumericValueEval) {return evaluateSingleProduct(args);}if(firstArg instanceof RefEval) {return evaluateSingleProduct(args);}if (firstArg instanceof TwoDEval) {TwoDEval ae = (TwoDEval) firstArg;if(ae.isRow() && ae.isColumn()) {return evaluateSingleProduct(args);}return evaluateAreaSumProduct(args);}} catch (EvaluationException e) {return e.getErrorEval();}throw new RuntimeException("Invalid arg type for SUMPRODUCT: ("+ firstArg.getClass().getName() + ")");}

// Translation:
public ValueEval Evaluate(ValueEval[] args, int srcCellRow, int srcCellCol){int maxN = args.Length;if (maxN < 1){return ErrorEval.VALUE_INVALID;}ValueEval firstArg = args[0];try{if (firstArg is NumericValueEval){return EvaluateSingleProduct(args);}if (firstArg is RefEval){return EvaluateSingleProduct(args);}if (firstArg is TwoDEval){TwoDEval ae = (TwoDEval)firstArg;if (ae.IsRow && ae.IsColumn){return EvaluateSingleProduct(args);}return EvaluateAreaSumProduct(args);}}catch (EvaluationException e){return e.GetErrorEval();}throw new RuntimeException("Invalid arg type for SUMPRODUCT: ("+ firstArg.GetType().Name + ")");}
// Original:
public DescribeParameterGroupsResult describeParameterGroups(DescribeParameterGroupsRequest request) {request = beforeClientExecution(request);return executeDescribeParameterGroups(request);}

// Translation:
public virtual DescribeParameterGroupsResponse DescribeParameterGroups(DescribeParameterGroupsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeParameterGroupsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeParameterGroupsResponseUnmarshaller.Instance;return Invoke<DescribeParameterGroupsResponse>(request, options);}
// Original:
public static char[] grow(char[] array, int minSize) {assert minSize >= 0: "size must be positive (got " + minSize + "): likely integer overflow?";if (array.length < minSize) {return growExact(array, oversize(minSize, Character.BYTES));} elsereturn array;}

// Translation:
public static bool[] Grow(bool[] array, int minSize){Debug.Assert(minSize >= 0, "size must be positive (got " + minSize + "): likely integer overflow?");if (array.Length < minSize){bool[] newArray = new bool[Oversize(minSize, 1)];Array.Copy(array, 0, newArray, 0, array.Length);return newArray;}else{return array;}}
// Original:
public double readDouble() throws IOException {return primitiveTypes.readDouble();}

// Translation:
public virtual double readDouble(){throw new System.NotImplementedException();}
// Original:
public void setTokenSource(TokenSource tokenSource) {this.tokenSource = tokenSource;tokens.clear();p = -1;fetchedEOF = false;}

// Translation:
public virtual void SetTokenSource(ITokenSource tokenSource){this._tokenSource = tokenSource;tokens.Clear();p = -1;this.fetchedEOF = false;}
// Original:
public void reset(Parser recognizer) {endErrorCondition(recognizer);}

// Translation:
public virtual void Reset(Parser recognizer){EndErrorCondition(recognizer);}
// Original:
public DescribeVpcPeeringAuthorizationsResult describeVpcPeeringAuthorizations(DescribeVpcPeeringAuthorizationsRequest request) {request = beforeClientExecution(request);return executeDescribeVpcPeeringAuthorizations(request);}

// Translation:
public virtual DescribeVpcPeeringAuthorizationsResponse DescribeVpcPeeringAuthorizations(DescribeVpcPeeringAuthorizationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeVpcPeeringAuthorizationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeVpcPeeringAuthorizationsResponseUnmarshaller.Instance;return Invoke<DescribeVpcPeeringAuthorizationsResponse>(request, options);}