}

    private static boolean doGet(Object val, boolean def) {
        if (val instanceof Boolean bool) {
            return bool;
        } else if (val != null) {
            return Boolean.parseBoolean(val.toString());
        } else {
            return def;
        }
    }

            if (intervalPongsReceived < intervalPingsSent) {
              return@withLock true
            } else {
              intervalPingsSent++
              return@withLock false
            }
          }
        if (failDueToMissingPong) {
          failConnection(null)
          return@schedule -1L
        } else {
          writePing(false, INTERVAL_PING, 0)
          return@schedule pingIntervalNanos
        }

        if (provider != null) {
            TimeZone providedTimeZone = provider.provide();
            assertEquals(FessUserTimeZoneProcessProvider.centralTimeZone, providedTimeZone);
        } else {
            // Cannot test due to reflection access limitations
            assertTrue("Cannot access DBFluteSystem fields via reflection", true);
        }
    }

			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Tiers")
				return
			}
			if z.Tiers == nil {
				z.Tiers = make(map[string]tierStats, zb0002)
			} else if len(z.Tiers) > 0 {
				for key := range z.Tiers {
					delete(z.Tiers, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 tierStats
				za0001, err = dc.ReadString()

  }

  private void enqueueStoppingEvent(State from) {
    if (from == State.STARTING) {
      listeners.enqueue(STOPPING_FROM_STARTING_EVENT);
    } else if (from == State.RUNNING) {
      listeners.enqueue(STOPPING_FROM_RUNNING_EVENT);
    } else {
      throw new AssertionError();
    }
  }

  private void enqueueTerminatedEvent(State from) {
    switch (from) {
      case NEW:

                        if (newItem != null) {
                            itemList.add(newItem);
                        } else {
                            id--;
                        }
                    } else {
                        itemList.add(item);
                    }
                }
            }
            if (updater != null) {

          }
          peekHeader.tagClass == Adapters.GENERALIZED_TIME.tagClass &&
            peekHeader.tag == Adapters.GENERALIZED_TIME.tag -> {
            Adapters.GENERALIZED_TIME.fromDer(reader)
          }
          else -> throw ProtocolException("expected time but was $peekHeader at $reader")
        }
      }

      override fun toDer(
        writer: DerWriter,
        value: Long,
      ) {

            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);

                response.setRegistrationId(registrationId);
                response.setContextHandle(contextHandle);

                log.debug("Witness registration successful: {}", registrationId);
            } else {
                response.setError(message.getErrorMessage());
                log.warn("Witness registration failed: {}", message.getErrorMessage());
            }

            return response;

                        ssn.setAttribute("NtlmHttpChal", chal);
                    }
                    dc = chal.dc;
                    challenge = chal.challenge;
                } else {
                    dc = getTransportContext().getNameServiceClient().getByName(this.domainController, true);
                    challenge = getTransportContext().getTransportPool().getChallenge(getTransportContext(), dc);