fmt.Printf("%t\n", unicode.IsDigit('৩'))
	fmt.Printf("%t\n", unicode.IsDigit('A'))
	// Output:
	// true
	// false
}

func ExampleIsNumber() {
	fmt.Printf("%t\n", unicode.IsNumber('Ⅷ'))
	fmt.Printf("%t\n", unicode.IsNumber('A'))
	// Output:
	// true
	// false
}

func ExampleIsLetter() {
	fmt.Printf("%t\n", unicode.IsLetter('A'))
	fmt.Printf("%t\n", unicode.IsLetter('7'))
	// Output:

func IsMark(r rune) bool {
	// There are no mark characters in Latin-1.
	return isExcludingLatin(Mark, r)
}

// IsNumber reports whether the rune is a number (category [N]).
func IsNumber(r rune) bool {
	if uint32(r) <= MaxLatin1 {
		return properties[uint8(r)]&pN != 0
	}
	return isExcludingLatin(Number, r)
}

// IsPunct reports whether the rune is a Unicode punctuation character
// (category [P]).

	// determine column widths and contents
	var widths []int
	var number []bool
	for _, line := range lines {
		for i, col := range line {
			if i < len(widths) {
				if len(col) > widths[i] {
					widths[i] = len(col)
				}
			} else {
				widths = append(widths, len(col))
				number = append(number, isnumber(col)) // first line determines column contents
			}
		}
	}

		if got != want {
			t.Errorf("%U incorrect: got %t; want %t", i, got, want)
		}
	}
}

func TestNumberLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsNumber(i)
		want := Is(Number, i)
		if got != want {
			t.Errorf("%U incorrect: got %t; want %t", i, got, want)
		}
	}
}

func TestIsPrintLatin1(t *testing.T) {
	for i := rune(0); i <= MaxLatin1; i++ {
		got := IsPrint(i)

			return string(strconv.AppendInt(append([]byte(frame.File), ':'), int64(frame.Line), 10))
		}
	}

	return ""
}

func IsValidDBNameChar(c rune) bool {
	return !unicode.IsLetter(c) && !unicode.IsNumber(c) && c != '.' && c != '*' && c != '_' && c != '$' && c != '@'
}

// CheckTruth check string true or not
func CheckTruth(vals ...string) bool {
	for _, val := range vals {

	"P-224",
	"P-256",
	"P-521",
	"P-384",
	"X25519",
	"X25519Kyber768Draft00",
)

func IsValidCipherSuite(cs string) bool {
	if cs == "" || cs == "ALL" {
		return true
	}
	if !unicode.IsNumber(rune(cs[0])) && !unicode.IsLetter(rune(cs[0])) {
		// Not all of these are correct, but this is needed to support advanced cases like - and + operators
		// without needing to parse the full expression
		return true
	}

func IsDigit (r <type -21>) <type -15>;
func IsGraphic (r <type -21>) <type -15>;
func IsLetter (r <type -21>) <type -15>;
func IsLower (r <type -21>) <type -15>;
func IsMark (r <type -21>) <type -15>;
func IsNumber (r <type -21>) <type -15>;
func IsOneOf (ranges <type 23 [] <type 24 *<type 2>>>, r <type -21>) <type -15>;
func IsPrint (r <type -21>) <type -15>;
func IsPunct (r <type -21>) <type -15>;
func IsSpace (r <type -21>) <type -15>;

            Long numericPart2 = numericParts2[i];

            boolean is1Number = numericPart1 != null;
            boolean is2Number = numericPart2 != null;

            if (part1.equals(part2)) {
                continue;
            }
            if (is1Number && !is2Number) {
                return 1;
            }
            if (is2Number && !is1Number) {
                return -1;
            }

      },
      "preferredLanguage" : {
        "type" : "keyword"
      },
      "departmentNumber" : {
        "type" : "keyword"
      },
      "uidNumber" : {
        "type" : "long"
      },
      "gidNumber" : {
        "type" : "long"
      },
      "homeDirectory" : {
        "type" : "keyword"
      },
      "groups": {
        "type": "keyword"
      },

            "type" : "keyword"
          },
          "employeeType" : {
            "type" : "keyword"
          },
          "facsimileTelephoneNumber" : {
            "type" : "keyword"
          },
          "gidNumber" : {
            "type" : "long"
          },
          "givenName" : {
            "type" : "keyword"
          },
          "groups" : {
            "type" : "keyword"
          },