var C = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "C",
		Aliases:   []string{"c"},
		Filenames: []string{"*.c", "*.h", "*.idc", "*.x[bp]m"},
		MimeTypes: []string{"text/x-chdr", "text/x-csrc", "image/x-xbitmap", "image/x-xpixmap"},
		EnsureNL:  true,
	},
	cRules,
))

var CPP = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "C++",
		Aliases:   []string{"cpp", "c++"},
		Filenames: []string{"*.cpp", "*.hpp", "*.c++", "*.h++", "*.cc", "*.hh", "*.cxx", "*.hxx", "*.C", "*.H", "*.cp", "*.CPP"},
		MimeTypes: []string{"text/x-c++hdr", "text/x-c++src"},
		EnsureNL:  true,
	},
	cppRules,
))

var CSS = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "CSS",
		Aliases:   []string{"css"},
		Filenames: []string{"*.css"},
		MimeTypes: []string{"text/css"},
	},
	cssRules,
))

var CSharp = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "C#",
		Aliases:   []string{"csharp", "c#"},
		Filenames: []string{"*.cs"},
		MimeTypes: []string{"text/x-csharp"},
		DotAll:    true,
		EnsureNL:  true,
	},
	cSharpRules,
))

var Caddyfile = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Caddyfile",
		Aliases:   []string{"caddyfile", "caddy"},
		Filenames: []string{"Caddyfile*"},
		MimeTypes: []string{},
	},
	caddyfileRules,
))

var CaddyfileDirectives = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Caddyfile Directives",
		Aliases:   []string{"caddyfile-directives", "caddyfile-d", "caddy-d"},
		Filenames: []string{},
		MimeTypes: []string{},
	},
	caddyfileDirectivesRules,
))

var CapNProto = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Cap'n Proto",
		Aliases:   []string{"capnp"},
		Filenames: []string{"*.capnp"},
		MimeTypes: []string{},
	},
	capNProtoRules,
))

var CassandraCQL = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "Cassandra CQL",
		Aliases:         []string{"cassandra", "cql"},
		Filenames:       []string{"*.cql"},
		MimeTypes:       []string{"text/x-cql"},
		NotMultiline:    true,
		CaseInsensitive: true,
	},
	cassandraCQLRules,
))

var Ceylon = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Ceylon",
		Aliases:   []string{"ceylon"},
		Filenames: []string{"*.ceylon"},
		MimeTypes: []string{"text/x-ceylon"},
		DotAll:    true,
	},
	ceylonRules,
))

var Cfengine3 = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "CFEngine3",
		Aliases:   []string{"cfengine3", "cf3"},
		Filenames: []string{"*.cf"},
		MimeTypes: []string{},
	},
	cfengine3Rules,
))

var Cfstatement = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "cfstatement",
		Aliases:         []string{"cfs"},
		Filenames:       []string{},
		MimeTypes:       []string{},
		NotMultiline:    true,
		CaseInsensitive: true,
	},
	cfstatementRules,
))

var Chaiscript = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "ChaiScript",
		Aliases:   []string{"chai", "chaiscript"},
		Filenames: []string{"*.chai"},
		MimeTypes: []string{"text/x-chaiscript", "application/x-chaiscript"},
		DotAll:    true,
	},
	chaiscriptRules,
))

var Cheetah = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Cheetah",
		Aliases:   []string{"cheetah", "spitfire"},
		Filenames: []string{"*.tmpl", "*.spt"},
		MimeTypes: []string{"application/x-cheetah", "application/x-spitfire"},
	},
	cheetahRules,
))

var Clojure = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Clojure",
		Aliases:   []string{"clojure", "clj"},
		Filenames: []string{"*.clj"},
		MimeTypes: []string{"text/x-clojure", "application/x-clojure"},
	},
	clojureRules,
))

var Cmake = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "CMake",
		Aliases:   []string{"cmake"},
		Filenames: []string{"*.cmake", "CMakeLists.txt"},
		MimeTypes: []string{"text/x-cmake"},
	},
	cmakeRules,
))

var Cobol = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "COBOL",
		Aliases:         []string{"cobol"},
		Filenames:       []string{"*.cob", "*.COB", "*.cpy", "*.CPY"},
		MimeTypes:       []string{"text/x-cobol"},
		CaseInsensitive: true,
	},
	cobolRules,
))

var Coffeescript = internal.Register(MustNewLazyLexer(
	&Config{
		Name:         "CoffeeScript",
		Aliases:      []string{"coffee-script", "coffeescript", "coffee"},
		Filenames:    []string{"*.coffee"},
		MimeTypes:    []string{"text/coffeescript"},
		NotMultiline: true,
		DotAll:       true,
	},
	coffeescriptRules,
))

var CommonLisp = internal.Register(TypeRemappingLexer(MustNewLazyLexer(
	&Config{
		Name:            "Common Lisp",
		Aliases:         []string{"common-lisp", "cl", "lisp"},
		Filenames:       []string{"*.cl", "*.lisp"},
		MimeTypes:       []string{"text/x-common-lisp"},
		CaseInsensitive: true,
	},
	commonLispRules,
), TypeMapping{
	{NameVariable, NameFunction, clBuiltinFunctions},
	{NameVariable, Keyword, clSpecialForms},
	{NameVariable, NameBuiltin, clMacros},
	{NameVariable, Keyword, clLambdaListKeywords},
	{NameVariable, Keyword, clDeclarations},
	{NameVariable, KeywordType, clBuiltinTypes},
	{NameVariable, NameClass, clBuiltinClasses},
}))

var Coq = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Coq",
		Aliases:   []string{"coq"},
		Filenames: []string{"*.v"},
		MimeTypes: []string{"text/x-coq"},
	},
	coqRules,
))

var Crystal = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Crystal",
		Aliases:   []string{"cr", "crystal"},
		Filenames: []string{"*.cr"},
		MimeTypes: []string{"text/x-crystal"},
		DotAll:    true,
	},
	crystalRules,
))

var Cython = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Cython",
		Aliases:   []string{"cython", "pyx", "pyrex"},
		Filenames: []string{"*.pyx", "*.pxd", "*.pxi"},
		MimeTypes: []string{"text/x-cython", "application/x-cython"},
	},
	cythonRules,
))