this.createDisposition = FILE_CREATE;
            } else {
                this.createDisposition = FILE_OPEN_IF;
            }
        } else {
            this.createDisposition = FILE_OPEN;
        }

        if ((createOptions & 0x0001) == 0) {
            this.createOptions = createOptions | 0x0040;
        } else {
            this.createOptions = createOptions;
        }

            if ("web".equals(systemLastaEnv)) {
                cmdList.add("-Dlasta.env=" + getExecuteType());
            } else {
                cmdList.add("-Dlasta.env=" + systemLastaEnv);
            }
        } else if (StringUtil.isNotBlank(lastaEnv)) {
            cmdList.add("-Dlasta.env=" + lastaEnv);
        } else {
            cmdList.add("-Dlasta.env=" + getExecuteType());
        }

        addFessConfigProperties(cmdList);

    val performanceTestTypes =
        if (performanceTestSpec.performanceTestType == PerformanceTestType.FLAKINESS_DETECTION) {
            listOf(PerformanceTestType.PER_COMMIT, PerformanceTestType.PER_DAY)
        } else {
            listOf(performanceTestSpec.performanceTestType)
        }
    return performanceTestConfigurations.flatMap { configuration ->
        configuration.groups
            .filter { group ->

          itr.remove();
          result.add(v);
        }
      }
      if (result.isEmpty()) {
        return null;
      } else if (unfiltered instanceof SetMultimap) {
        return unmodifiableSet(new LinkedHashSet<>(result));
      } else {
        return unmodifiableList(result);
      }
    }

    @Override
    Set<K> createKeySet() {
      @WeakOuter

            scenarios.flatMap { scenario ->
                Os.values().flatMap { os ->
                    val arch = if (os == Os.MACOS) Arch.AARCH64 else Arch.AMD64
                    if (os == Os.WINDOWS) {
                        listOf("jprofiler")
                    } else {
                        listOf("async-profiler", "async-profiler-heap")
                    }.map { FlameGraphGenerationBuildSpec(scenario, os, arch, it) }

            // add to both; the one already containing it will have more
            multiset1.add(element);
            multiset2.add(element);
          } else if (i % 2 == 0) {
            multiset1.add(elements[i]);
          } else {
            multiset2.add(elements[i]);
          }
        }
        return union(multiset1, multiset2);
      }
    };
  }

            totalDataCount = writeDataWireFormat(txn_buf, bufDataOffset);

            dataCount = Math.min(totalDataCount, available);
        } else {
            if (command != SMB_COM_NT_TRANSACT) {
                command = SMB_COM_TRANSACTION_SECONDARY;
            } else {
                command = SMB_COM_NT_TRANSACT_SECONDARY;
            }
            // totalParameterCount and totalDataCount are set ok from primary

			if len(mm) != 1 {
				t.Errorf("%s: invalid errorcheck line:\n%s", fileline, line)
			} else if err := errors[fileline]; err == "" {
				t.Errorf("%s: missing error, want %s", fileline, all)
			} else if !strings.Contains(err, mm[0][1]) {
				t.Errorf("%s: wrong error for %s:\n%s", fileline, all, err)
			}
		} else {
			if errors[fileline] != "" {
				t.Errorf("unexpected error on %s: %v", fileline, errors[fileline])

            return false;
        }
        final String value;
        if (urlStr.startsWith("://")) {
            value = "http" + urlStr;
        } else if (urlStr.startsWith("//")) {
            value = "http:" + urlStr;
        } else {
            value = urlStr;
        }
        try {
            final URL url = new URL(value);
            final String host = url.getHost();

                        query = queries[i];
                    } else {
                        query = normalizer.normalize(queries[i], "", langsArray);
                    }

                    if (readingConverter == null) {
                        readingList.add(query);
                    } else {
                        readingList = readingConverter.convert(query, "", langsArray);