return false
	}
	return true
}

func GetFd(f fs.File) (uintptr, error) {
	if fdable, ok := f.(interface{ Fd() uintptr }); ok {
		return fdable.Fd(), nil
	}

	return 0, fmt.Errorf("unable to get fd")
}

/// mostly copy pasted from spire below:

// regexes listed here have to exclusively match a cgroup path
// the regexes must include two named groups "poduid" and "containerid"

            <type>Dependency</type>
            <multiplicity>*</multiplicity>
          </association>
          <description>
            A set of dependencies which the plugin requires in order to function. This enables the plugin to function
            independently of its POM (or at least to declare the libraries it needs to run).
          </description>
        </field>
      </fields>
      <codeSegments>

            return properties;
        }

        try (Reader reader = Files.newBufferedReader(path)) {
            properties.load(reader);
        } catch (IOException e) {
            LOGGER.warn("Unable to read {}. The --resume / -r feature will not work.", path);
        }

        return properties;
    }

    // This method is made package-private for testing purposes

    Collection<String> collection = map.values();

    LenientSerializableTester.reserializeAndAssertElementsEqual(collection);
  }

  // TODO: Re-enable this test after moving to new serialization format in ImmutableMap.
  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  @SuppressWarnings("unchecked")

    @Execute(urlPattern = "{}/@word")
    public JsonResponse<ApiResult> post$start(final String id) {
        scheduledJobService.getScheduledJob(id).ifPresent(entity -> {
            if (!entity.isEnabled() || entity.isRunning()) {
                throwValidationErrorApi(messages -> {
                    messages.addErrorsFailedToStartJob(GLOBAL, entity.getName());
                });
            }
            try {

	if err != nil {
		return cfg, err
	}
	cfg.ExcessFolders = excessFolders

	switch idleSpeed := env.Get(EnvIdleSpeed, kvs.GetWithDefault(IdleSpeed, DefaultKVS)); idleSpeed {
	case "", config.EnableOn:
		cfg.IdleMode = 0
	case config.EnableOff:
		cfg.IdleMode = 1
	default:
		return cfg, fmt.Errorf("unknown value: '%s'", idleSpeed)
	}

          .apply {
            isAccessible = true
          }
          .get(this) as? SecretKey

    val randomRegex = "\"random\"\\s+:\\s+\"([^\"]+)\"".toRegex()

    fun register() {
      // Enable JUL logging for SSL events, must be activated early or via -D option.
      System.setProperty("javax.net.debug", "")
      logger =
        Logger.getLogger("javax.net.ssl")
          .apply {

                    if (handler != null) break;
                }
            }
            if (handler == null) {
                throw new IOException(
                        "Unable to find default handler for protocol: " +
                                protocol);
            }
            PROTOCOL_HANDLERS.put(protocol, handler);
            return handler;
        }
    }

			entry = *auditEntry
		}
	}

	// Send audit logs only to http targets.
	for _, t := range auditTgts {
		if err := t.Send(ctx, entry); err != nil {
			LogOnceIf(ctx, "logging", fmt.Errorf("Unable to send audit event(s) to the target `%v`: %v", t, err), "send-audit-event-failure")
		}
	}

val pgpSigningPassPhrase: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE")
val signArtifacts: Boolean = !pgpSigningKey.orNull.isNullOrEmpty()

tasks.withType<Sign>().configureEach { isEnabled = signArtifacts }

signing {
    useInMemoryPgpKeys(pgpSigningKey.orNull, pgpSigningPassPhrase.orNull)
    publishing.publications.configureEach {
        if (signArtifacts) {
            signing.sign(this)