b = b[len(x):]
	}
	return s
}

func concatstring2(buf *tmpBuf, a0, a1 string) string {
	return concatstrings(buf, []string{a0, a1})
}

func concatstring3(buf *tmpBuf, a0, a1, a2 string) string {
	return concatstrings(buf, []string{a0, a1, a2})
}

func concatstring4(buf *tmpBuf, a0, a1, a2, a3 string) string {
	return concatstrings(buf, []string{a0, a1, a2, a3})
}

	print("\n")

	/* create string with integer constant */
	c = string('x')
	if c != "x" {
		panic("create int " + c)
	}

	/* create string with integer variable */
	v := 'x'
	c = string(v)
	if c != "x" {
		panic("create int " + c)
	}

	/* create string with byte array */
	var z1 [3]byte
	z1[0] = 'a'
	z1[1] = 'b'
	z1[2] = 'c'
	c = string(z1[0:])
	if c != "abc" {

// If the value passed in is not actually a map, this will panic.
func StringKeySet[T any](theMap map[string]T) String {
	return String(KeySet(theMap))
}

// Insert adds items to the set.
func (s String) Insert(items ...string) String {
	return String(cast(s).Insert(items...))
}

// Delete removes all items from the set.
func (s String) Delete(items ...string) String {

 */

package org.gradle.kotlin.dsl.support

import org.gradle.util.internal.TextUtil.convertLineSeparatorsToUnix
import java.util.Locale


fun String.normaliseLineSeparators(): String =
    convertLineSeparatorsToUnix(this)


fun String.uppercaseFirstChar(): String =

// started.
package cryptobyte // import "golang.org/x/crypto/cryptobyte"

// String represents a string of bytes. It provides methods for parsing
// fixed-length and length-prefixed values from it.
type String []byte

// read advances a String by n bytes and returns them. If less than n bytes
// remain, it returns nil.
func (s *String) read(n int) []byte {

#include "tensorflow/cc/experimental/libtf/impl/string.h"

#include <unordered_set>

// It is important for the container below to not invalidate pointers to
// elements when elements are inserted, because the String class stores such
// pointers. This rules out, for example, absl::flat_hash_set.
using StringTable = std::unordered_set<std::string>;

namespace tf {
namespace libtf {
namespace impl {

package org.gradle.kotlin.dsl.fixtures


fun <T> Iterable<T>.joinLines(transform: (T) -> String) =

	matcher "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3"
)

// StringMatcher creates a string matcher for v.
func StringMatcher(v string) *matcher.StringMatcher {
	return StringMatcherWithPrefix(v, "")
}

// StringOrMatcher creates an OR string matcher for a list of values.
func StringOrMatcher(vs []string) *matcher.ValueMatcher {
	matchers := []*matcher.ValueMatcher{}
	for _, v := range vs {

// necessary so that we can use alias type names that may not be reachable from
// inType itself).
func describe(typ, inType types.Type, inName string) string {
	name := inName
	if typ != inType {
		name = typeName(typ)
	}
	if name == "" {
		return ""
	}

	var parentheticals []string
	if underName := typeName(typ.Underlying()); underName != "" && underName != name {
		parentheticals = append(parentheticals, underName)
	}

   */
  explicit String(const char* s);

  String() : String("") {}
  String(const String& s) : value_(s.value_) {}

  // This is the same as the default equality operator, which works because
  // we're interning all strings. It is specified here so we are explicit about
  // it. We're not saying "= default;" because we can't use C++20 features yet.
  bool operator==(const String& other) const { return value_ == other.value_; }