@Override
    String normalizeWord(String word) {
      return Ascii.toLowerCase(word);
    }

    @Override
    String convert(CaseFormat format, String s) {
      if (format == LOWER_UNDERSCORE) {
        return s.replace('-', '_');
      }
      if (format == UPPER_UNDERSCORE) {
        return Ascii.toUpperCase(s.replace('-', '_'));
      }
      return super.convert(format, s);
    }
  },

         * use of this method.
         */
        if ( this.hostName.isUnknown() ) {
            return getHostAddress();
        }
        return this.hostName.name;
    }


    @Override
    public NetbiosName getName () {
        return this.hostName;
    }


    /**
     * Returns the raw IP address of this NbtAddress. The result is in network

      lastTimeoutInMillis = unit.toMillis(timeout);
      return inline.submit(Iterables.get(tasks, 0)).get(timeout, unit);
    }

    @Override
    public boolean isShutdown() {
      lastMethodCalled = "isShutdown";
      return false;
    }

    @Override
    public boolean isTerminated() {
      lastMethodCalled = "isTerminated";
      return false;
    }

    @Override

			return
		}
	}
	// write "Checksum"
	err = en.Append(0xa8, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d)
	if err != nil {
		return
	}
	err = en.WriteString(z.Checksum)
	if err != nil {
		err = msgp.WrapError(err, "Checksum")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ServerSystemConfig) MarshalMsg(b []byte) (o []byte, err error) {

   * a "null sentinel" to take its place. When the time comes to convert it back to a {@code T} to
   * return to a caller, the code needs to a way to return {@code null} from a method that returns
   * "plain {@code T}." This API provides that.
   */
  @SuppressWarnings({"nullness", "TypeParameterUnusedInFormals", "ReturnMissingNullable"})
  // The warnings are legitimate. Each time we use this method, we document why.
  @ParametricNullness

      if (isOptional) return defaultValue as T
      throw ProtocolException("expected $this but was $peekedHeader at $reader")
    }

    val result =
      reader.read(name) {
        codec.decode(reader)
      }

    if (typeHint) {
      reader.typeHint = result
    }

    return result
  }

  override fun toDer(
    writer: DerWriter,
    value: T,

    statsCounterSupplier = CACHE_STATS_COUNTER;
    return this;
  }

  boolean isRecordingStats() {
    return statsCounterSupplier == CACHE_STATS_COUNTER;
  }

  Supplier<? extends StatsCounter> getStatsCounterSupplier() {
    return statsCounterSupplier;
  }

  /**
   * Builds a cache, which either returns an already-loaded value for a given key or atomically

//            dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0x00;
            dst[start + ANDX_OFFSET_OFFSET] = (byte)0xde;
            dst[start + ANDX_OFFSET_OFFSET + 1] = (byte)0xde;

            // andx not used; return
            return dstIndex - start;
        }

        /* The message provided to batch has a batchLimit that is
         * higher than the current batchLevel so we will now encode

        public String getDisplayName() {
            return signature;
        }

        public String getUrlFragment(String className) {
            return style == LinkMetaData.Style.Dsldoc ? String.format("%s:%s", className, signature) : signature.replace('(', '-').replace(')', '-');
        }

        @Override
        public String toString() {
            return signature;
        }
    }

    }

    public boolean include(Artifact artifact) {
        return !toInvert.include(artifact);
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + toInvert.hashCode();
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }