Datasets:

AhmedSSoliman

/

CodeXGLUE-CodeTans

like 0

public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {for (int i = 0; i < iterations; ++i) {final int byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = byte0 >>> 5;values[valuesOffset++] = (byte0 >>> 2) & 7;final int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | (byte1 >>> 7);values[valuesOffset++] = (byte1 >>> 4) & 7;values[valuesOffset++] = (byte1 >>> 1) & 7;final int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | (byte2 >>> 6);values[valuesOffset++] = (byte2 >>> 3) & 7;values[valuesOffset++] = byte2 & 7;}}

public override void Decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations){for (int i = 0; i < iterations; ++i){int byte0 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = (int)((uint)byte0 >> 5);values[valuesOffset++] = ((int)((uint)byte0 >> 2)) & 7;int byte1 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte0 & 3) << 1) | ((int)((uint)byte1 >> 7));values[valuesOffset++] = ((int)((uint)byte1 >> 4)) & 7;values[valuesOffset++] = ((int)((uint)byte1 >> 1)) & 7;int byte2 = blocks[blocksOffset++] & 0xFF;values[valuesOffset++] = ((byte1 & 1) << 2) | ((int)((uint)byte2 >> 6));values[valuesOffset++] = ((int)((uint)byte2 >> 3)) & 7;values[valuesOffset++] = byte2 & 7;}}

public GetRelationalDatabaseSnapshotResult getRelationalDatabaseSnapshot(GetRelationalDatabaseSnapshotRequest request) {request = beforeClientExecution(request);return executeGetRelationalDatabaseSnapshot(request);}

public virtual GetRelationalDatabaseSnapshotResponse GetRelationalDatabaseSnapshot(GetRelationalDatabaseSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetRelationalDatabaseSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = GetRelationalDatabaseSnapshotResponseUnmarshaller.Instance;return Invoke<GetRelationalDatabaseSnapshotResponse>(request, options);}

public int fillFields(byte[] data, int offset, EscherRecordFactory recordFactory) {int bytesRemaining = readHeader( data, offset );int pos = offset + 8;field_1_blipTypeWin32 = data[pos];field_2_blipTypeMacOS = data[pos + 1];System.arraycopy( data, pos + 2, field_3_uid, 0, 16 );field_4_tag = LittleEndian.getShort( data, pos + 18 );field_5_size = LittleEndian.getInt( data, pos + 20 );field_6_ref = LittleEndian.getInt( data, pos + 24 );field_7_offset = LittleEndian.getInt( data, pos + 28 );field_8_usage = data[pos + 32];field_9_name = data[pos + 33];field_10_unused2 = data[pos + 34];field_11_unused3 = data[pos + 35];bytesRemaining -= 36;int bytesRead = 0;if (bytesRemaining > 0) {field_12_blipRecord = (EscherBlipRecord) recordFactory.createRecord( data, pos + 36 );bytesRead = field_12_blipRecord.fillFields( data, pos + 36, recordFactory );}pos += 36 + bytesRead;bytesRemaining -= bytesRead;_remainingData = IOUtils.safelyAllocate(bytesRemaining, MAX_RECORD_LENGTH);System.arraycopy( data, pos, _remainingData, 0, bytesRemaining );return bytesRemaining + 8 + 36 + (field_12_blipRecord == null ? 0 : field_12_blipRecord.getRecordSize()) ;}

public override int FillFields(byte[] data, int offset,IEscherRecordFactory recordFactory){int bytesRemaining = ReadHeader(data, offset);int pos = offset + 8;field_1_blipTypeWin32 = data[pos];field_2_blipTypeMacOS = data[pos + 1];field_3_uid = new byte[16];Array.Copy(data, pos + 2, field_3_uid, 0, 16);field_4_tag = LittleEndian.GetShort(data, pos + 18);field_5_size = LittleEndian.GetInt(data, pos + 20);field_6_ref = LittleEndian.GetInt(data, pos + 24);field_7_offset = LittleEndian.GetInt(data, pos + 28);field_8_usage = data[pos + 32];field_9_name = data[pos + 33];field_10_unused2 = data[pos + 34];field_11_unused3 = data[pos + 35];bytesRemaining -= 36;int bytesRead = 0;if (bytesRemaining > 0){field_12_blipRecord = (EscherBlipRecord)recordFactory.CreateRecord(data, pos + 36);bytesRead = field_12_blipRecord.FillFields(data, pos + 36, recordFactory);}pos += 36 + bytesRead;bytesRemaining -= bytesRead;_remainingData = new byte[bytesRemaining];Array.Copy(data, pos, _remainingData, 0, bytesRemaining);return bytesRemaining + 8 + 36 + (field_12_blipRecord == null ? 0 : field_12_blipRecord.RecordSize);}

@Override public int size() {return size;}

public override int size(){return a.Length;}

public PhoneNumberValidateResult phoneNumberValidate(PhoneNumberValidateRequest request) {request = beforeClientExecution(request);return executePhoneNumberValidate(request);}

public virtual PhoneNumberValidateResponse PhoneNumberValidate(PhoneNumberValidateRequest request){var options = new InvokeOptions();options.RequestMarshaller = PhoneNumberValidateRequestMarshaller.Instance;options.ResponseUnmarshaller = PhoneNumberValidateResponseUnmarshaller.Instance;return Invoke<PhoneNumberValidateResponse>(request, options);}

public CreateTransformJobResult createTransformJob(CreateTransformJobRequest request) {request = beforeClientExecution(request);return executeCreateTransformJob(request);}

public virtual CreateTransformJobResponse CreateTransformJob(CreateTransformJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateTransformJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateTransformJobResponseUnmarshaller.Instance;return Invoke<CreateTransformJobResponse>(request, options);}

public synchronized int search(Object o) {final Object[] dumpArray = elementData;final int size = elementCount;if (o != null) {for (int i = size - 1; i >= 0; i--) {if (o.equals(dumpArray[i])) {return size - i;}}} else {for (int i = size - 1; i >= 0; i--) {if (dumpArray[i] == null) {return size - i;}}}return -1;}

public virtual int search(object o){lock (this){object[] dumpArray = elementData;int size_1 = elementCount;if (o != null){{for (int i = size_1 - 1; i >= 0; i--){if (o.Equals(dumpArray[i])){return size_1 - i;}}}}else{{for (int i = size_1 - 1; i >= 0; i--){if (dumpArray[i] == null){return size_1 - i;}}}}return -1;}}

public DescribeCacheParametersRequest(String cacheParameterGroupName) {setCacheParameterGroupName(cacheParameterGroupName);}

public DescribeCacheParametersRequest(string cacheParameterGroupName){_cacheParameterGroupName = cacheParameterGroupName;}

public void clear() {synchronized (mutex) {delegate().clear();}}

public virtual void clear(){lock (mutex){c.clear();}}

public boolean hasRevSort(RevSort sort) {return sorting.contains(sort);}

public virtual bool HasRevSort(RevSort sort){return sorting.Contains(sort);}

public StashListCommand stashList() {return new StashListCommand(repo);}

public virtual StashListCommand StashList(){return new StashListCommand(repo);}

public PutGroupPolicyRequest(String groupName, String policyName, String policyDocument) {setGroupName(groupName);setPolicyName(policyName);setPolicyDocument(policyDocument);}

public PutGroupPolicyRequest(string groupName, string policyName, string policyDocument){_groupName = groupName;_policyName = policyName;_policyDocument = policyDocument;}

public String toString() {return super.get() + "=" + value;}

public override string ToString(){return base.get() + "=" + value;}

public void writeByte(int v) {checkPosition(1);_buf[_writeIndex++] = (byte)v;}

public void WriteByte(int v){CheckPosition(1);_buf[_writeIndex++] = (byte)v;}

public CountryRecord(RecordInputStream in) {field_1_default_country = in.readShort();field_2_current_country = in.readShort();}

public CountryRecord(RecordInputStream in1){field_1_default_country = in1.ReadShort();field_2_current_country = in1.ReadShort();}

public UpdateContainerAgentResult updateContainerAgent(UpdateContainerAgentRequest request) {request = beforeClientExecution(request);return executeUpdateContainerAgent(request);}

public virtual UpdateContainerAgentResponse UpdateContainerAgent(UpdateContainerAgentRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateContainerAgentRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateContainerAgentResponseUnmarshaller.Instance;return Invoke<UpdateContainerAgentResponse>(request, options);}

public DescribeNodeConfigurationOptionsResult describeNodeConfigurationOptions(DescribeNodeConfigurationOptionsRequest request) {request = beforeClientExecution(request);return executeDescribeNodeConfigurationOptions(request);}

public virtual DescribeNodeConfigurationOptionsResponse DescribeNodeConfigurationOptions(DescribeNodeConfigurationOptionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeNodeConfigurationOptionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeNodeConfigurationOptionsResponseUnmarshaller.Instance;return Invoke<DescribeNodeConfigurationOptionsResponse>(request, options);}

public AddImageRequest() {super("ImageSearch", "2019-03-25", "AddImage", "imagesearch");setUriPattern("/v2/image/add");setMethod(MethodType.POST);}

public AddImageRequest(): base("ImageSearch", "2019-03-25", "AddImage", "imagesearch", "openAPI"){UriPattern = "/v2/image/add";Method = MethodType.POST;}

public BorderFormatting() {field_13_border_styles1 = 0;field_14_border_styles2 = 0;}

public BorderFormatting(){field_13_border_styles1 = (short)0;field_14_border_styles2 = (short)0;}

public String toFormulaString(String[] operands) {StringBuilder buffer = new StringBuilder();buffer.append(operands[0]);buffer.append(" ");buffer.append(operands[1]);return buffer.toString();}

public override String ToFormulaString(String[] operands){StringBuilder buffer = new StringBuilder();buffer.Append(operands[0]);buffer.Append(" ");buffer.Append(operands[1]);return buffer.ToString();}

public ListTagsForStreamResult listTagsForStream(ListTagsForStreamRequest request) {request = beforeClientExecution(request);return executeListTagsForStream(request);}

public virtual ListTagsForStreamResponse ListTagsForStream(ListTagsForStreamRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTagsForStreamRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTagsForStreamResponseUnmarshaller.Instance;return Invoke<ListTagsForStreamResponse>(request, options);}

public HSSFName createName(){NameRecord nameRecord = workbook.createName();HSSFName newName = new HSSFName(this, nameRecord);names.add(newName);return newName;}

public NPOI.SS.UserModel.IName CreateName(){NameRecord nameRecord = workbook.CreateName();HSSFName newName = new HSSFName(this, nameRecord);names.Add(newName);return newName;}

public CreateLogPatternResult createLogPattern(CreateLogPatternRequest request) {request = beforeClientExecution(request);return executeCreateLogPattern(request);}

public virtual CreateLogPatternResponse CreateLogPattern(CreateLogPatternRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateLogPatternRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateLogPatternResponseUnmarshaller.Instance;return Invoke<CreateLogPatternResponse>(request, options);}

public GetTransitGatewayRouteTablePropagationsResult getTransitGatewayRouteTablePropagations(GetTransitGatewayRouteTablePropagationsRequest request) {request = beforeClientExecution(request);return executeGetTransitGatewayRouteTablePropagations(request);}

public virtual GetTransitGatewayRouteTablePropagationsResponse GetTransitGatewayRouteTablePropagations(GetTransitGatewayRouteTablePropagationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTransitGatewayRouteTablePropagationsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTransitGatewayRouteTablePropagationsResponseUnmarshaller.Instance;return Invoke<GetTransitGatewayRouteTablePropagationsResponse>(request, options);}

public void setup() throws Exception {super.setup();String inputDirProp = getRunData().getConfig().get(ADDINDEXES_INPUT_DIR, null);if (inputDirProp == null) {throw new IllegalArgumentException("config parameter " + ADDINDEXES_INPUT_DIR + " not specified in configuration");}inputDir = FSDirectory.open(Paths.get(inputDirProp));}

public override void Setup(){base.Setup();string inputDirProp = RunData.Config.Get(ADDINDEXES_INPUT_DIR, null);if (inputDirProp == null){throw new ArgumentException("config parameter " + ADDINDEXES_INPUT_DIR + " not specified in configuration");}inputDir = FSDirectory.Open(new DirectoryInfo(inputDirProp));}

public StashDropCommand setAll(boolean all) {this.all = all;return this;}

public virtual NGit.Api.StashDropCommand SetAll(bool all){this.all = all;return this;}

public ListTrainingJobsForHyperParameterTuningJobResult listTrainingJobsForHyperParameterTuningJob(ListTrainingJobsForHyperParameterTuningJobRequest request) {request = beforeClientExecution(request);return executeListTrainingJobsForHyperParameterTuningJob(request);}

public virtual ListTrainingJobsForHyperParameterTuningJobResponse ListTrainingJobsForHyperParameterTuningJob(ListTrainingJobsForHyperParameterTuningJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTrainingJobsForHyperParameterTuningJobRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTrainingJobsForHyperParameterTuningJobResponseUnmarshaller.Instance;return Invoke<ListTrainingJobsForHyperParameterTuningJobResponse>(request, options);}

public String toString() {return String.format("Match %s; found %d labels",succeeded() ? "succeeded" : "failed",getLabels().size());}

public override string ToString(){return string.Format("Match {0}; found {1} labels", Succeeded ? "succeeded" : "failed", Labels.Count);}

public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {double result;try {double d = singleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = evaluate(d);checkValue(result);} catch (EvaluationException e) {return e.getErrorEval();}return new NumberEval(result);}

public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){double result;try{double d = NumericFunction.SingleOperandEvaluate(arg0, srcRowIndex, srcColumnIndex);result = Evaluate(d);NumericFunction.CheckValue(result);}catch (EvaluationException e){return e.GetErrorEval();}return new NumberEval(result);}

public CacheSecurityGroup authorizeCacheSecurityGroupIngress(AuthorizeCacheSecurityGroupIngressRequest request) {request = beforeClientExecution(request);return executeAuthorizeCacheSecurityGroupIngress(request);}

public virtual AuthorizeCacheSecurityGroupIngressResponse AuthorizeCacheSecurityGroupIngress(AuthorizeCacheSecurityGroupIngressRequest request){var options = new InvokeOptions();options.RequestMarshaller = AuthorizeCacheSecurityGroupIngressRequestMarshaller.Instance;options.ResponseUnmarshaller = AuthorizeCacheSecurityGroupIngressResponseUnmarshaller.Instance;return Invoke<AuthorizeCacheSecurityGroupIngressResponse>(request, options);}

public String getInflectionType() {return dictionary.getInflectionType(wordId);}

public virtual string GetInflectionType(){return dictionary.GetInflectionType(wordId);}

@Override public boolean remove(Object o) {return contains(o) &&(removeValuesForKey(((Multiset.Entry<?>) o).getElement()) > 0);}

public override bool remove(object o){if (!(o is java.util.MapClass.Entry<K, V>)){return false;}java.util.MapClass.Entry<object, object> e = (java.util.MapClass.Entry<object, object>)o;return this._enclosing.removeMapping(e.getKey(), e.getValue());}

public RevCommit next() {RevCommit r = next;next = nextForIterator();return r;}

public virtual RevCommit Next(){return pending.Next();}

public BatchAssociateUserStackResult batchAssociateUserStack(BatchAssociateUserStackRequest request) {request = beforeClientExecution(request);return executeBatchAssociateUserStack(request);}

public virtual BatchAssociateUserStackResponse BatchAssociateUserStack(BatchAssociateUserStackRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchAssociateUserStackRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchAssociateUserStackResponseUnmarshaller.Instance;return Invoke<BatchAssociateUserStackResponse>(request, options);}

public ScenarioProtectRecord clone() {return copy();}

public override Object Clone(){ScenarioProtectRecord rec = new ScenarioProtectRecord();rec.field_1_protect = field_1_protect;return rec;}

public final Class getBundleClass() {return bundleClass;}

public Type GetBundleClass(){return bundleClass;}

public void nextBuffer() {if (1+bufferUpto == buffers.length) {int[][] newBuffers = new int[(int) (buffers.length*1.5)][];System.arraycopy(buffers, 0, newBuffers, 0, buffers.length);buffers = newBuffers;}buffer = buffers[1+bufferUpto] = allocator.getIntBlock();bufferUpto++;intUpto = 0;intOffset += INT_BLOCK_SIZE;}

public void NextBuffer(){if (1 + bufferUpto == buffers.Length){int[][] newBuffers = new int[(int)(buffers.Length * 1.5)][];Array.Copy(buffers, 0, newBuffers, 0, buffers.Length);buffers = newBuffers;}buffer = buffers[1 + bufferUpto] = allocator.GetInt32Block();bufferUpto++;Int32Upto = 0;Int32Offset += INT32_BLOCK_SIZE;}

public DeleteVpnGatewayRequest(String vpnGatewayId) {setVpnGatewayId(vpnGatewayId);}

public DeleteVpnGatewayRequest(string vpnGatewayId){_vpnGatewayId = vpnGatewayId;}

public static Encoder getEncoder(Format format, int version, int bitsPerValue) {checkVersion(version);return BulkOperation.of(format, bitsPerValue);}

public static IEncoder GetEncoder(Format format, int version, int bitsPerValue){CheckVersion(version);return BulkOperation.Of(format, bitsPerValue);}

public ClassificationResult(T assignedClass, double score) {this.assignedClass = assignedClass;this.score = score;}

public ClassificationResult(T assignedClass, double score){_assignedClass = assignedClass;_score = score;}

public CreateRelationalDatabaseSnapshotResult createRelationalDatabaseSnapshot(CreateRelationalDatabaseSnapshotRequest request) {request = beforeClientExecution(request);return executeCreateRelationalDatabaseSnapshot(request);}

public virtual CreateRelationalDatabaseSnapshotResponse CreateRelationalDatabaseSnapshot(CreateRelationalDatabaseSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateRelationalDatabaseSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateRelationalDatabaseSnapshotResponseUnmarshaller.Instance;return Invoke<CreateRelationalDatabaseSnapshotResponse>(request, options);}

public NameRecord addName(NameRecord name) {getOrCreateLinkTable().addName(name);return name;}

public NameRecord AddName(NameRecord name){OrCreateLinkTable.AddName(name);return name;}

public void serialize(LittleEndianOutput out) {out.writeShort(getFirstRow());out.writeShort(getLastRow());out.writeByte(getFirstColumn());out.writeByte(getLastColumn());}

public void Serialize(ILittleEndianOutput out1){out1.WriteShort(FirstRow);out1.WriteShort(LastRow);out1.WriteByte(FirstColumn);out1.WriteByte(LastColumn);}

public String getKey() {return key;}

public virtual string GetKey(){return key;}

public GetBlockPublicAccessConfigurationResult getBlockPublicAccessConfiguration(GetBlockPublicAccessConfigurationRequest request) {request = beforeClientExecution(request);return executeGetBlockPublicAccessConfiguration(request);}

public virtual GetBlockPublicAccessConfigurationResponse GetBlockPublicAccessConfiguration(GetBlockPublicAccessConfigurationRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetBlockPublicAccessConfigurationRequestMarshaller.Instance;options.ResponseUnmarshaller = GetBlockPublicAccessConfigurationResponseUnmarshaller.Instance;return Invoke<GetBlockPublicAccessConfigurationResponse>(request, options);}

public static long getResultSize(byte[] delta) {int p = 0;int c;do {c = delta[p++] & 0xff;} while ((c & 0x80) != 0);long resLen = 0;int shift = 0;do {c = delta[p++] & 0xff;resLen |= ((long) (c & 0x7f)) << shift;shift += 7;} while ((c & 0x80) != 0);return resLen;}

public static long GetResultSize(byte[] delta){int p = 0;int c;do{c = delta[p++] & unchecked((int)(0xff));}while ((c & unchecked((int)(0x80))) != 0);long resLen = 0;int shift = 0;do{c = delta[p++] & unchecked((int)(0xff));resLen |= ((long)(c & unchecked((int)(0x7f)))) << shift;shift += 7;}while ((c & unchecked((int)(0x80))) != 0);return resLen;}

public long ramBytesUsed() {return RamUsageEstimator.alignObjectSize(RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + Integer.BYTES);}

public override long RamBytesUsed(){return RamUsageEstimator.AlignObjectSize(RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + RamUsageEstimator.NUM_BYTES_INT32);}

public NoteRecord() {field_6_author = "";field_3_flags = 0;field_7_padding = DEFAULT_PADDING; }

public NoteRecord(){field_6_author = "";field_3_flags = 0;field_7_padding = DEFAULT_PADDING; }

public CellReference[] getAllReferencedCells() {if(_isSingleCell) {return new CellReference[] { _firstCell, };}int minRow = Math.min(_firstCell.getRow(), _lastCell.getRow());int maxRow = Math.max(_firstCell.getRow(), _lastCell.getRow());int minCol = Math.min(_firstCell.getCol(), _lastCell.getCol());int maxCol = Math.max(_firstCell.getCol(), _lastCell.getCol());String sheetName = _firstCell.getSheetName();List<CellReference> refs = new ArrayList<>();for(int row=minRow; row<=maxRow; row++) {for(int col=minCol; col<=maxCol; col++) {CellReference ref = new CellReference(sheetName, row, col, _firstCell.isRowAbsolute(), _firstCell.isColAbsolute());refs.add(ref);}}return refs.toArray(new CellReference[0]);}

public CellReference[] GetAllReferencedCells(){if (_isSingleCell){return new CellReference[] { _firstCell, };}int minRow = Math.Min(_firstCell.Row, _lastCell.Row);int maxRow = Math.Max(_firstCell.Row, _lastCell.Row);int minCol = Math.Min(_firstCell.Col, _lastCell.Col);int maxCol = Math.Max(_firstCell.Col, _lastCell.Col);String sheetName = _firstCell.SheetName;ArrayList refs = new ArrayList();for (int row = minRow; row <= maxRow; row++){for (int col = minCol; col <= maxCol; col++){CellReference ref1 = new CellReference(sheetName, row, col, _firstCell.IsRowAbsolute, _firstCell.IsColAbsolute);refs.Add(ref1);}}return (CellReference[])refs.ToArray(typeof(CellReference));}

public String[] listAll() {ensureOpen();String[] res = entries.keySet().toArray(new String[entries.size()]);for (int i = 0; i < res.length; i++) {res[i] = segmentName + res[i];}return res;}

public override string[] ListAll(){EnsureOpen();string[] res;if (writer != null){res = writer.ListAll();}else{res = entries.Keys.ToArray();string seg = IndexFileNames.ParseSegmentName(fileName);for (int i = 0; i < res.Length; i++){res[i] = seg + res[i];}}return res;}

public UpdateDataRetentionResult updateDataRetention(UpdateDataRetentionRequest request) {request = beforeClientExecution(request);return executeUpdateDataRetention(request);}

public virtual UpdateDataRetentionResponse UpdateDataRetention(UpdateDataRetentionRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateDataRetentionRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateDataRetentionResponseUnmarshaller.Instance;return Invoke<UpdateDataRetentionResponse>(request, options);}

public CreateDistributionRequest(DistributionConfig distributionConfig) {setDistributionConfig(distributionConfig);}

public CreateDistributionRequest(DistributionConfig distributionConfig){_distributionConfig = distributionConfig;}

public DescribeBatchPredictionsResult describeBatchPredictions(DescribeBatchPredictionsRequest request) {request = beforeClientExecution(request);return executeDescribeBatchPredictions(request);}

public virtual DescribeBatchPredictionsResponse DescribeBatchPredictions(DescribeBatchPredictionsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeBatchPredictionsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeBatchPredictionsResponseUnmarshaller.Instance;return Invoke<DescribeBatchPredictionsResponse>(request, options);}

public float getScore(int index) {return scores[index];}

public virtual float GetScore(int index){return scores[index];}

public BatchUpdatePhoneNumberResult batchUpdatePhoneNumber(BatchUpdatePhoneNumberRequest request) {request = beforeClientExecution(request);return executeBatchUpdatePhoneNumber(request);}

public virtual BatchUpdatePhoneNumberResponse BatchUpdatePhoneNumber(BatchUpdatePhoneNumberRequest request){var options = new InvokeOptions();options.RequestMarshaller = BatchUpdatePhoneNumberRequestMarshaller.Instance;options.ResponseUnmarshaller = BatchUpdatePhoneNumberResponseUnmarshaller.Instance;return Invoke<BatchUpdatePhoneNumberResponse>(request, options);}

public LMSimilarity(CollectionModel collectionModel) {this.collectionModel = collectionModel;}

public LMSimilarity(ICollectionModel collectionModel){this.m_collectionModel = collectionModel;}

public GetGlobalSettingsResult getGlobalSettings(GetGlobalSettingsRequest request) {request = beforeClientExecution(request);return executeGetGlobalSettings(request);}

public virtual GetGlobalSettingsResponse GetGlobalSettings(GetGlobalSettingsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetGlobalSettingsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetGlobalSettingsResponseUnmarshaller.Instance;return Invoke<GetGlobalSettingsResponse>(request, options);}

public CreateHITTypeResult createHITType(CreateHITTypeRequest request) {request = beforeClientExecution(request);return executeCreateHITType(request);}

public virtual CreateHITTypeResponse CreateHITType(CreateHITTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateHITTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateHITTypeResponseUnmarshaller.Instance;return Invoke<CreateHITTypeResponse>(request, options);}

public MLTConfig build() {return new MLTConfig(this);}

public CompositeReaderContext Build(){return (CompositeReaderContext)Build(null, reader, 0, 0);}

public CharsRef(String string) {this.chars = string.toCharArray();this.offset = 0;this.length = chars.length;}

public CharsRef(string @string){this.chars = @string.ToCharArray();this.Offset = 0;this.Length = chars.Length;}

public ListFargateProfilesResult listFargateProfiles(ListFargateProfilesRequest request) {request = beforeClientExecution(request);return executeListFargateProfiles(request);}

public virtual ListFargateProfilesResponse ListFargateProfiles(ListFargateProfilesRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListFargateProfilesRequestMarshaller.Instance;options.ResponseUnmarshaller = ListFargateProfilesResponseUnmarshaller.Instance;return Invoke<ListFargateProfilesResponse>(request, options);}

public Entry<K, V> floorEntry(K key) {return immutableCopy(findBounded(key, FLOOR));}

public java.util.MapClass.Entry<K, V> floorEntry(K key){return this._enclosing.immutableCopy(this.findBounded(key, java.util.TreeMap.Relation.FLOOR));}

public boolean equals( Object o ) {return o instanceof NorwegianStemmer;}

public override bool Equals(object o){return o is NorwegianStemmer;}

public DeleteVaultNotificationsResult deleteVaultNotifications(DeleteVaultNotificationsRequest request) {request = beforeClientExecution(request);return executeDeleteVaultNotifications(request);}

public virtual DeleteVaultNotificationsResponse DeleteVaultNotifications(DeleteVaultNotificationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteVaultNotificationsRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteVaultNotificationsResponseUnmarshaller.Instance;return Invoke<DeleteVaultNotificationsResponse>(request, options);}

public static boolean endsWith(char s[], int len, String suffix) {final int suffixLen = suffix.length();if (suffixLen > len)return false;for (int i = suffixLen - 1; i >= 0; i--)if (s[len -(suffixLen - i)] != suffix.charAt(i))return false;return true;}

public static bool EndsWith(char[] s, int len, string suffix){int suffixLen = suffix.Length;if (suffixLen > len){return false;}for (int i = suffixLen - 1; i >= 0; i--){if (s[len - (suffixLen - i)] != suffix[i]){return false;}}return true;}

public synchronized void setRequireDimCount(String dimName, boolean v) {DimConfig ft = fieldTypes.get(dimName);if (ft == null) {ft = new DimConfig();fieldTypes.put(dimName, ft);}ft.requireDimCount = v;}

public virtual void SetRequireDimCount(string dimName, bool v){lock (this){if (!fieldTypes.TryGetValue(dimName, out DimConfig fieldType)){fieldTypes[dimName] = new DimConfig { RequireDimCount = v };}else{fieldType.RequireDimCount = v;}}}

public HSSFName getName(String name) {int nameIndex = getNameIndex(name);if (nameIndex < 0) {return null;}return names.get(nameIndex);}

public NPOI.SS.UserModel.IName GetName(String name){int nameIndex = GetNameIndex(name);if (nameIndex < 0){return null;}return (HSSFName)names[nameIndex];}

public ScriptBootstrapActionConfig(String path, java.util.List<String> args) {setPath(path);setArgs(args);}

public ScriptBootstrapActionConfig(string path, List<string> args){_path = path;_args = args;}

public RegisterApplicationRevisionResult registerApplicationRevision(RegisterApplicationRevisionRequest request) {request = beforeClientExecution(request);return executeRegisterApplicationRevision(request);}

public virtual RegisterApplicationRevisionResponse RegisterApplicationRevision(RegisterApplicationRevisionRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterApplicationRevisionRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterApplicationRevisionResponseUnmarshaller.Instance;return Invoke<RegisterApplicationRevisionResponse>(request, options);}

public SendTestEventNotificationResult sendTestEventNotification(SendTestEventNotificationRequest request) {request = beforeClientExecution(request);return executeSendTestEventNotification(request);}

public virtual SendTestEventNotificationResponse SendTestEventNotification(SendTestEventNotificationRequest request){var options = new InvokeOptions();options.RequestMarshaller = SendTestEventNotificationRequestMarshaller.Instance;options.ResponseUnmarshaller = SendTestEventNotificationResponseUnmarshaller.Instance;return Invoke<SendTestEventNotificationResponse>(request, options);}

public void setRefLogIdent(PersonIdent pi) {refLogIdent = pi;}

public virtual void SetRefLogIdent(PersonIdent pi){refLogIdent = pi;}

public GetDomainDeliverabilityCampaignResult getDomainDeliverabilityCampaign(GetDomainDeliverabilityCampaignRequest request) {request = beforeClientExecution(request);return executeGetDomainDeliverabilityCampaign(request);}

public virtual GetDomainDeliverabilityCampaignResponse GetDomainDeliverabilityCampaign(GetDomainDeliverabilityCampaignRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetDomainDeliverabilityCampaignRequestMarshaller.Instance;options.ResponseUnmarshaller = GetDomainDeliverabilityCampaignResponseUnmarshaller.Instance;return Invoke<GetDomainDeliverabilityCampaignResponse>(request, options);}

public String toFormulaString() {StringBuilder b = new StringBuilder();b.append("{");for (int y = 0; y < _nRows; y++) {if (y > 0) {b.append(";");}for (int x = 0; x < _nColumns; x++) {if (x > 0) {b.append(",");}Object o = _arrayValues[getValueIndex(x, y)];b.append(getConstantText(o));}}b.append("}");return b.toString();}

public override String ToFormulaString(){StringBuilder b = new StringBuilder();b.Append("{");for (int y = 0; y < RowCount; y++){if (y > 0){b.Append(";");}for (int x = 0; x < ColumnCount; x++){if (x > 0){b.Append(",");}Object o = _arrayValues.GetValue(GetValueIndex(x, y));b.Append(GetConstantText(o));}}b.Append("}");return b.ToString();}

public ShingleFilterFactory(Map<String, String> args) {super(args);maxShingleSize = getInt(args, "maxShingleSize", ShingleFilter.DEFAULT_MAX_SHINGLE_SIZE);if (maxShingleSize < 2) {throw new IllegalArgumentException("Invalid maxShingleSize (" + maxShingleSize + ") - must be at least 2");}minShingleSize = getInt(args, "minShingleSize", ShingleFilter.DEFAULT_MIN_SHINGLE_SIZE);if (minShingleSize < 2) {throw new IllegalArgumentException("Invalid minShingleSize (" + minShingleSize + ") - must be at least 2");}if (minShingleSize > maxShingleSize) {throw new IllegalArgumentException("Invalid minShingleSize (" + minShingleSize + ") - must be no greater than maxShingleSize (" + maxShingleSize + ")");}outputUnigrams = getBoolean(args, "outputUnigrams", true);outputUnigramsIfNoShingles = getBoolean(args, "outputUnigramsIfNoShingles", false);tokenSeparator = get(args, "tokenSeparator", ShingleFilter.DEFAULT_TOKEN_SEPARATOR);fillerToken = get(args, "fillerToken", ShingleFilter.DEFAULT_FILLER_TOKEN);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

public ShingleFilterFactory(IDictionary<string, string> args): base(args){maxShingleSize = GetInt32(args, "maxShingleSize", ShingleFilter.DEFAULT_MAX_SHINGLE_SIZE);if (maxShingleSize < 2){throw new ArgumentOutOfRangeException("Invalid maxShingleSize (" + maxShingleSize + ") - must be at least 2");}minShingleSize = GetInt32(args, "minShingleSize", ShingleFilter.DEFAULT_MIN_SHINGLE_SIZE);if (minShingleSize < 2){throw new ArgumentOutOfRangeException("Invalid minShingleSize (" + minShingleSize + ") - must be at least 2");}if (minShingleSize > maxShingleSize){throw new ArgumentOutOfRangeException("Invalid minShingleSize (" + minShingleSize + ") - must be no greater than maxShingleSize (" + maxShingleSize + ")");}outputUnigrams = GetBoolean(args, "outputUnigrams", true);outputUnigramsIfNoShingles = GetBoolean(args, "outputUnigramsIfNoShingles", false);tokenSeparator = Get(args, "tokenSeparator", ShingleFilter.DEFAULT_TOKEN_SEPARATOR);fillerToken = Get(args, "fillerToken", ShingleFilter.DEFAULT_FILLER_TOKEN);if (args.Count > 0){throw new ArgumentException("Unknown parameters: " + args);}}

public UpdateRelationalDatabaseParametersResult updateRelationalDatabaseParameters(UpdateRelationalDatabaseParametersRequest request) {request = beforeClientExecution(request);return executeUpdateRelationalDatabaseParameters(request);}

public virtual UpdateRelationalDatabaseParametersResponse UpdateRelationalDatabaseParameters(UpdateRelationalDatabaseParametersRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateRelationalDatabaseParametersRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateRelationalDatabaseParametersResponseUnmarshaller.Instance;return Invoke<UpdateRelationalDatabaseParametersResponse>(request, options);}

public static Collection<ParseTree> findAllRuleNodes(ParseTree t, int ruleIndex) {return findAllNodes(t, ruleIndex, false);}

public static ICollection<IParseTree> FindAllRuleNodes(IParseTree t, int ruleIndex){return FindAllNodes(t, ruleIndex, false);}

public int getObjectCount() {return entryCount;}

public virtual int GetObjectCount(){return entryCount;}

public ActionTransition(ATNState target, int ruleIndex, int actionIndex, boolean isCtxDependent) {super(target);this.ruleIndex = ruleIndex;this.actionIndex = actionIndex;this.isCtxDependent = isCtxDependent;}

public ActionTransition(ATNState target, int ruleIndex, int actionIndex, bool isCtxDependent): base(target){this.ruleIndex = ruleIndex;this.actionIndex = actionIndex;this.isCtxDependent = isCtxDependent;}

public long get(int index) {final int blockOffset = index / valuesPerBlock;final long skip = ((long) blockOffset) << 3;try {in.seek(startPointer + skip);long block = in.readLong();final int offsetInBlock = index % valuesPerBlock;return (block >>> (offsetInBlock * bitsPerValue)) & mask;} catch (IOException e) {throw new IllegalStateException("failed", e);}}

public override long Get(int index){int blockOffset = index / valuesPerBlock;long skip = ((long)blockOffset) << 3;try{@in.Seek(startPointer + skip);long block = @in.ReadInt64();int offsetInBlock = index % valuesPerBlock;return ((long)((ulong)block >> (offsetInBlock * m_bitsPerValue))) & mask;}catch (System.IO.IOException e){throw new InvalidOperationException("failed", e);}}

public String getSignerType() {return "BEARERTOKEN";}

public override string GetSignerType(){return "BEARERTOKEN";}

public PipedOutputStream(PipedInputStream target) throws IOException {connect(target);}

public PipedOutputStream(java.io.PipedInputStream target){throw new System.NotImplementedException();}

public DeleteLedgerResult deleteLedger(DeleteLedgerRequest request) {request = beforeClientExecution(request);return executeDeleteLedger(request);}

public virtual DeleteLedgerResponse DeleteLedger(DeleteLedgerRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteLedgerRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteLedgerResponseUnmarshaller.Instance;return Invoke<DeleteLedgerResponse>(request, options);}

public GetCognitoEventsResult getCognitoEvents(GetCognitoEventsRequest request) {request = beforeClientExecution(request);return executeGetCognitoEvents(request);}

public virtual GetCognitoEventsResponse GetCognitoEvents(GetCognitoEventsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCognitoEventsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCognitoEventsResponseUnmarshaller.Instance;return Invoke<GetCognitoEventsResponse>(request, options);}

public NameXPtg getNameXPtg(String name, SheetIdentifier sheet) {int sheetRefIndex = getSheetExtIx(sheet);return _iBook.getNameXPtg(name, sheetRefIndex, _uBook.getUDFFinder());}

public Ptg GetNameXPtg(String name, SheetIdentifier sheet){int sheetRefIndex = GetSheetExtIx(sheet);return _iBook.GetNameXPtg(name, sheetRefIndex, _uBook.GetUDFFinder());}

public ListResolverEndpointsResult listResolverEndpoints(ListResolverEndpointsRequest request) {request = beforeClientExecution(request);return executeListResolverEndpoints(request);}

public virtual ListResolverEndpointsResponse ListResolverEndpoints(ListResolverEndpointsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListResolverEndpointsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListResolverEndpointsResponseUnmarshaller.Instance;return Invoke<ListResolverEndpointsResponse>(request, options);}

public String readLine() {try {return reader.readLine();} catch (IOException e) {throw new IOError(e);}}

public string readLine(){try{return _reader.readLine();}catch (System.IO.IOException e){throw new java.io.IOError(e);}}

public int hash2(char carray[]) {int hash = 5381;for (int i = 0; i < carray.length; i++) {char d = carray[i];hash = ((hash << 5) + hash) + d & 0x00FF;hash = ((hash << 5) + hash) + d >> 8;}return hash;}

public virtual int Hash2(char[] carray){int hash = 5381;for (int i = 0; i < carray.Length; i++){char d = carray[i];hash = ((hash << 5) + hash) + d & 0x00FF;hash = ((hash << 5) + hash) + d >> 8;}return hash;}

public static long toBookSheetColumn(int bookIndex, int sheetIndex, int columnIndex) {return ((bookIndex & 0xFFFFL) << 48) +((sheetIndex & 0xFFFFL) << 32) +((columnIndex & 0xFFFFL) << 0);}

public static long ToBookSheetColumn(int bookIndex, int sheetIndex, int columnIndex){return ((bookIndex & 0xFFFFL) << 48) + ((sheetIndex & 0xFFFFL) << 32) + ((columnIndex & 0xFFFFL) << 0);}

public CreateConfigurationProfileResult createConfigurationProfile(CreateConfigurationProfileRequest request) {request = beforeClientExecution(request);return executeCreateConfigurationProfile(request);}

public virtual CreateConfigurationProfileResponse CreateConfigurationProfile(CreateConfigurationProfileRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateConfigurationProfileRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateConfigurationProfileResponseUnmarshaller.Instance;return Invoke<CreateConfigurationProfileResponse>(request, options);}

public ReplicationGroup startMigration(StartMigrationRequest request) {request = beforeClientExecution(request);return executeStartMigration(request);}

public virtual StartMigrationResponse StartMigration(StartMigrationRequest request){var options = new InvokeOptions();options.RequestMarshaller = StartMigrationRequestMarshaller.Instance;options.ResponseUnmarshaller = StartMigrationResponseUnmarshaller.Instance;return Invoke<StartMigrationResponse>(request, options);}

public OffsetLimitTokenFilter(TokenStream input, int offsetLimit) {super(input);this.offsetLimit = offsetLimit;}

public OffsetLimitTokenFilter(TokenStream input, int offsetLimit) : base(input){this.offsetLimit = offsetLimit;offsetAttrib = GetAttribute<IOffsetAttribute>();}

public final void write(byte[] b, int off, int len)throws IOException {while (0 < len) {final int n = Math.min(len, BYTES_TO_WRITE_BEFORE_CANCEL_CHECK);count += n;if (checkCancelAt <= count) {if (writeMonitor.isCancelled()) {throw new IOException(JGitText.get().packingCancelledDuringObjectsWriting);}checkCancelAt = count + BYTES_TO_WRITE_BEFORE_CANCEL_CHECK;}out.write(b, off, n);md.update(b, off, n);off += n;len -= n;}}

public override void Write(byte[] b, int off, int len){while (0 < len){int n = Math.Min(len, BYTES_TO_WRITE_BEFORE_CANCEL_CHECK);count += n;if (checkCancelAt <= count){if (writeMonitor.IsCancelled()){throw new IOException(JGitText.Get().packingCancelledDuringObjectsWriting);}checkCancelAt = count + BYTES_TO_WRITE_BEFORE_CANCEL_CHECK;}@out.Write(b, off, n);crc.Update(b, off, n);md.Update(b, off, n);off += n;len -= n;}}

public Cell merge(Cell m, Cell e) {Cell n = new Cell();if (m.skip != e.skip) {return null;}if (m.cmd >= 0) {if (e.cmd >= 0) {if (m.cmd == e.cmd) {n.cmd = m.cmd;} else {return null;}} else {n.cmd = m.cmd;}} else {n.cmd = e.cmd;}if (m.ref >= 0) {if (e.ref >= 0) {if (m.ref == e.ref) {if (m.skip == e.skip) {n.ref = m.ref;} else {return null;}} else {return null;}} else {n.ref = m.ref;}} else {n.ref = e.ref;}n.cnt = m.cnt + e.cnt;n.skip = m.skip;return n;}

public virtual Cell Merge(Cell m, Cell e){Cell n = new Cell();if (m.skip != e.skip){return null;}if (m.cmd >= 0){if (e.cmd >= 0){if (m.cmd == e.cmd){n.cmd = m.cmd;}else{return null;}}else{n.cmd = m.cmd;}}else{n.cmd = e.cmd;}if (m.@ref >= 0){if (e.@ref >= 0){if (m.@ref == e.@ref){if (m.skip == e.skip){n.@ref = m.@ref;}else{return null;}}else{return null;}}else{n.@ref = m.@ref;}}else{n.@ref = e.@ref;}n.cnt = m.cnt + e.cnt;n.skip = m.skip;return n;}

public GetCampaignActivitiesResult getCampaignActivities(GetCampaignActivitiesRequest request) {request = beforeClientExecution(request);return executeGetCampaignActivities(request);}

public virtual GetCampaignActivitiesResponse GetCampaignActivities(GetCampaignActivitiesRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCampaignActivitiesRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCampaignActivitiesResponseUnmarshaller.Instance;return Invoke<GetCampaignActivitiesResponse>(request, options);}

public long estimateBytesUsed() {return bytesUsed;}

public virtual long EstimateBytesUsed(){return this.bytesUsed;}

public FunctionNameEval(String functionName) {_functionName = functionName;}

public FunctionNameEval(String functionName) {_functionName = functionName;}

public final float averageBytesPerChar() {return averageBytesPerChar;}

public float averageBytesPerChar(){return _averageBytesPerChar;}

public CreateCacheSecurityGroupRequest(String cacheSecurityGroupName, String description) {setCacheSecurityGroupName(cacheSecurityGroupName);setDescription(description);}

public CreateCacheSecurityGroupRequest(string cacheSecurityGroupName, string description){_cacheSecurityGroupName = cacheSecurityGroupName;_description = description;}

public void removeAt(int index) {System.arraycopy(mKeys, index + 1, mKeys, index, mSize - (index + 1));System.arraycopy(mValues, index + 1, mValues, index, mSize - (index + 1));mSize--;}

public virtual void removeAt(int index){System.Array.Copy(mKeys, index + 1, mKeys, index, mSize - (index + 1));System.Array.Copy(mValues, index + 1, mValues, index, mSize - (index + 1));mSize--;}

public DescribeIndexFieldsResult describeIndexFields(DescribeIndexFieldsRequest request) {request = beforeClientExecution(request);return executeDescribeIndexFields(request);}

public virtual DescribeIndexFieldsResponse DescribeIndexFields(DescribeIndexFieldsRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeIndexFieldsRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeIndexFieldsResponseUnmarshaller.Instance;return Invoke<DescribeIndexFieldsResponse>(request, options);}