text:
functions = [
    "AbelianGroup",
    "AbelianInvariants",
    "AbelianInvariantsMultiplier",
    "AbelianInvariantsNormalClosureFpGroup",
    "AbelianInvariantsNormalClosureFpGroupRrs",
    "AbelianInvariantsOfList",
    "AbelianInvariantsSubgroupFpGroup",
    "AbelianInvariantsSubgroupFpGroupMtc",
    "AbelianInvariantsSubgroupFpGroupRrs",
    "AbelianNumberField",
    "AbelianSubfactorAction",
    "AbsInt",
    "AbsoluteIrreducibleModules",
    "AbsoluteValue",
    "AbsolutIrreducibleModules",
    "AbstractWordTietzeWord",
    "AClosestVectorCombinationsMatFFEVecFFE",
    "AClosestVectorCombinationsMatFFEVecFFECoords",
    "ActingAlgebra",
    "ActingDomain",
    "Action",
    "ActionHomomorphism",
    "ActorOfExternalSet",
    "Add",
    "AddCoeffs",
    "AddGenerator",
    "AddGenerators",
    "AddGeneratorsExtendSchreierTree",
    "AdditiveInverse",
    "AdditiveInverseAttr",
    "AdditiveInverseImmutable",
    "AdditiveInverseMutable",
    "AdditiveInverseOp",
    "AdditiveInverseSameMutability",
    "AdditiveInverseSM",
    "AdditiveNeutralElement",
    "AddRelator",
    "AddRowVector",
    "AddRule",
    "AddRuleReduced",
    "AddSet",
    "AdjointAssociativeAlgebra",
    "AdjointBasis",
    "AdjointMatrix",
    "AdjointModule",
    "AffineAction",
    "AffineActionLayer",
    "AffineOperation",
    "AffineOperationLayer",
    "Agemo",
    "Algebra",
    "AlgebraByStructureConstants",
    "AlgebraGeneralMappingByImages",
    "AlgebraHomomorphismByImages",
    "AlgebraHomomorphismByImagesNC",
    "AlgebraicExtension",
    "AlgebraWithOne",
    "AlgebraWithOneGeneralMappingByImages",
    "AlgebraWithOneHomomorphismByImages",
    "AlgebraWithOneHomomorphismByImagesNC",
    "AllBlocks",
    "AllIrreducibleSolvableGroups",
    "AllSmallGroups",
    "Alpha",
    "AlternatingGroup",
    "ANFAutomorphism",
    "AntiSymmetricParts",
    "Append",
    "AppendTo",
    "ApplicableMethod",
    "ApplicableMethodTypes",
    "Apply",
    "ApplySimpleReflection",
    "ApproximateSuborbitsStabilizerPermGroup",
    "ARCH_IS_MAC",
    "ARCH_IS_UNIX",
    "ARCH_IS_WINDOWS",
    "Arrangements",
    "AsAlgebra",
    "AsAlgebraWithOne",
    "AsBinaryRelationOnPoints",
    "AsBlockMatrix",
    "AscendingChain",
    "AsDivisionRing",
    "AsDuplicateFreeList",
    "AsField",
    "AsFreeLeftModule",
    "AsGroup",
    "AsGroupGeneralMappingByImages",
    "AsLeftIdeal",
    "AsLeftModule",
    "AsList",
    "AsMagma",
    "AsMonoid",
    "AsPolynomial",
    "AsRightIdeal",
    "AsRing",
    "AsSemigroup",
    "Assert",
    "AssertionLevel",
    "AsSet",
    "AssignGeneratorVariables",
    "AssignNiceMonomorphismAutomorphismGroup",
    "AssociatedPartition",
    "AssociatedReesMatrixSemigroupOfDClass",
    "Associates",
    "AssocWordByLetterRep",
    "AsSortedList",
    "AsSSortedList",
    "AsSubalgebra",
    "AsSubalgebraWithOne",
    "AsSubgroup",
    "AsSubgroupOfWholeGroupByQuotient",
    "AsSubmagma",
    "AsSubmonoid",
    "AsSubsemigroup",
    "AsSubspace",
    "AsTransformation",
    "AsTransformationNC",
    "AsTwoSidedIdeal",
    "AsVectorSpace",
    "AtlasIrrationality",
    "AttributeValueNotSet",
    "AugmentationIdeal",
    "AugmentedCosetTableInWholeGroup",
    "AugmentedCosetTableMtc",
    "AugmentedCosetTableRrs",
    "AutomorphismDomain",
    "AutomorphismGroup",
    "AutomorphismsOfTable",
    "BaseFixedSpace",
    "BaseIntersectionIntMats",
    "BaseIntMat",
    "BaseMat",
    "BaseMatDestructive",
    "BaseOfGroup",
    "BaseOrthogonalSpaceMat",
    "BaseStabChain",
    "BaseSteinitzVectors",
    "BasicWreathProductOrdering",
    "Basis",
    "BasisNC",
    "BasisVectors",
    "Bell",
    "Bernoulli",
    "BestQuoInt",
    "BestSplittingMatrix",
    "BiAlgebraModule",
    "BiAlgebraModuleByGenerators",
    "BilinearFormMat",
    "BinaryRelationByElements",
    "BinaryRelationOnPoints",
    "BinaryRelationOnPointsNC",
    "BinaryRelationTransformation",
    "BindGlobal",
    "Binomial",
    "BlistList",
    "BlockMatrix",
    "Blocks",
    "BlocksInfo",
    "BlownUpMat",
    "BlownUpVector",
    "BlowUpIsomorphism",
    "BombieriNorm",
    "BrauerCharacterValue",
    "BrauerTable",
    "BrauerTableOp",
    "BravaisGroup",
    "BravaisSubgroups",
    "BravaisSupergroups",
    "CallFuncList",
    "CanComputeIndex",
    "CanComputeIsSubset",
    "CanComputeSize",
    "CanComputeSizeAnySubgroup",
    "CanEasilyCompareElements",
    "CanEasilyCompareElementsFamily",
    "CanEasilyComputePcgs",
    "CanEasilySortElements",
    "CanEasilySortElementsFamily",
    "CanEasilyTestMembership",
    "CanonicalBasis",
    "CanonicalGenerators",
    "CanonicalPcElement",
    "CanonicalPcgs",
    "CanonicalPcgsByGeneratorsWithImages",
    "CanonicalRepresentativeDeterminatorOfExternalSet",
    "CanonicalRepresentativeOfExternalSet",
    "CanonicalRightCosetElement",
    "CartanMatrix",
    "CartanSubalgebra",
    "Cartesian",
    "CategoriesOfObject",
    "CategoryCollections",
    "Center",
    "CentralCharacter",
    "CentralIdempotentsOfAlgebra",
    "Centralizer",
    "CentralizerInGLnZ",
    "CentralizerModulo",
    "CentralizerSizeLimitConsiderFunction",
    "CentralNormalSeriesByPcgs",
    "Centre",
    "CentreOfCharacter",
    "ChangeStabChain",
    "Character",
    "CharacterDegrees",
    "Characteristic",
    "CharacteristicPolynomial",
    "CharacterNames",
    "CharacterParameters",
    "CharacterTable",
    "CharacterTableDirectProduct",
    "CharacterTableFactorGroup",
    "CharacterTableIsoclinic",
    "CharacterTableRegular",
    "CharacterTableWithSortedCharacters",
    "CharacterTableWithSortedClasses",
    "CharacterTableWreathSymmetric",
    "CHAR_INT",
    "CHAR_SINT",
    "CheckFixedPoints",
    "CheckForHandlingByNiceBasis",
    "CheckPermChar",
    "ChevalleyBasis",
    "ChiefNormalSeriesByPcgs",
    "ChiefSeries",
    "ChiefSeriesThrough",
    "ChiefSeriesUnderAction",
    "ChineseRem",
    "Chomp",
    "CIUnivPols",
    "ClassElementLattice",
    "ClassesSolvableGroup",
    "ClassFunction",
    "ClassFunctionSameType",
    "ClassMultiplicationCoefficient",
    "ClassNames",
    "ClassNamesTom",
    "ClassOrbit",
    "ClassParameters",
    "ClassPermutation",
    "ClassPositionsOfAgemo",
    "ClassPositionsOfCentre",
    "ClassPositionsOfDerivedSubgroup",
    "ClassPositionsOfDirectProductDecompositions",
    "ClassPositionsOfElementaryAbelianSeries",
    "ClassPositionsOfFittingSubgroup",
    "ClassPositionsOfKernel",
    "ClassPositionsOfLowerCentralSeries",
    "ClassPositionsOfMaximalNormalSubgroups",
    "ClassPositionsOfMinimalNormalSubgroups",
    "ClassPositionsOfNormalClosure",
    "ClassPositionsOfNormalSubgroup",
    "ClassPositionsOfNormalSubgroups",
    "ClassPositionsOfSupersolvableResiduum",
    "ClassPositionsOfUpperCentralSeries",
    "ClassRoots",
    "ClassStructureCharTable",
    "ClassTypesTom",
    "CleanedTailPcElement",
    "ClearCacheStats",
    "ClearProfile",
    "CloseMutableBasis",
    "CloseStream",
    "ClosureGroup",
    "ClosureGroupAddElm",
    "ClosureGroupCompare",
    "ClosureGroupDefault",
    "ClosureGroupIntest",
    "ClosureLeftModule",
    "ClosureNearAdditiveGroup",
    "ClosureRing",
    "ClosureSubgroup",
    "ClosureSubgroupNC",
    "Coboundaries",
    "Cochain",
    "CochainSpace",
    "Cocycles",
    "CodePcGroup",
    "CodePcgs",
    "Coefficients",
    "CoefficientsAndMagmaElements",
    "CoefficientsFamily",
    "CoefficientsMultiadic",
    "CoefficientsOfLaurentPolynomial",
    "CoefficientsOfUnivariatePolynomial",
    "CoefficientsOfUnivariateRationalFunction",
    "CoefficientsQadic",
    "CoefficientsRing",
    "CoeffsCyc",
    "CoeffsMod",
    "CoKernelOfAdditiveGeneralMapping",
    "CoKernelOfMultiplicativeGeneralMapping",
    "CollapsedMat",
    "Collected",
    "CollectionsFamily",
    "ColorPrompt",
    "ColumnIndexOfReesMatrixSemigroupElement",
    "ColumnIndexOfReesZeroMatrixSemigroupElement",
    "Combinations",
    "CombinatorialCollector",
    "Comm",
    "CommutativeDiagram",
    "CommutatorFactorGroup",
    "CommutatorLength",
    "CommutatorSubgroup",
    "Compacted",
    "CompanionMat",
    "CompareVersionNumbers",
    "CompatibleConjugacyClasses",
    "CompatiblePairs",
    "Complementclasses",
    "ComplementclassesEA",
    "ComplementIntMat",
    "ComplementSystem",
    "ComplexConjugate",
    "ComplexificationQuat",
    "CompositionMapping",
    "CompositionMapping2",
    "CompositionMaps",
    "CompositionOfStraightLinePrograms",
    "CompositionSeries",
    "ComputedBrauerTables",
    "ComputedClassFusions",
    "ComputedIndicators",
    "ComputedIsPSolvableCharacterTables",
    "ComputedPowerMaps",
    "ComputedPrimeBlockss",
    "Concatenation",
    "Conductor",
    "ConfluentRws",
    "Congruences",
    "ConjugacyClass",
    "ConjugacyClasses",
    "ConjugacyClassesByOrbits",
    "ConjugacyClassesByRandomSearch",
    "ConjugacyClassesMaximalSubgroups",
    "ConjugacyClassesPerfectSubgroups",
    "ConjugacyClassesSubgroups",
    "ConjugacyClassSubgroups",
    "ConjugateDominantWeight",
    "ConjugateDominantWeightWithWord",
    "ConjugateGroup",
    "Conjugates",
    "ConjugateSubgroup",
    "ConjugateSubgroups",
    "ConjugatorAutomorphism",
    "ConjugatorAutomorphismNC",
    "ConjugatorIsomorphism",
    "ConjugatorOfConjugatorIsomorphism",
    "ConnectGroupAndCharacterTable",
    "ConsiderKernels",
    "ConsiderSmallerPowerMaps",
    "ConsiderStructureConstants",
    "ConsiderTableAutomorphisms",
    "ConstantTimeAccessList",
    "ConstituentsCompositionMapping",
    "ConstituentsOfCharacter",
    "ContainedCharacters",
    "ContainedDecomposables",
    "ContainedMaps",
    "ContainedPossibleCharacters",
    "ContainedPossibleVirtualCharacters",
    "ContainedSpecialVectors",
    "ContainedTom",
    "ContainingTom",
    "ContinuedFractionApproximationOfRoot",
    "ContinuedFractionExpansionOfRoot",
    "ConvertToCharacterTable",
    "ConvertToCharacterTableNC",
    "ConvertToMatrixRep",
    "ConvertToMatrixRepNC",
    "ConvertToRangeRep",
    "ConvertToStringRep",
    "ConvertToTableOfMarks",
    "ConvertToVectorRep",
    "ConvertToVectorRepNC",
    "ConwayPolynomial",
    "COPY_LIST_ENTRIES",
    "CopyOptionsDefaults",
    "CopyStabChain",
    "Core",
    "CorrespondingGeneratorsByModuloPcgs",
    "CosetLeadersMatFFE",
    "CosetTable",
    "CosetTableBySubgroup",
    "CosetTableFromGensAndRels",
    "CosetTableInWholeGroup",
    "CosetTableOfFpSemigroup",
    "CrcFile",
    "CreateCompletionFiles",
    "Cycle",
    "CycleLength",
    "CycleLengths",
    "Cycles",
    "CycleStructureClass",
    "CycleStructurePerm",
    "CyclicExtensionsTom",
    "CyclicGroup",
    "CyclotomicField",
    "CyclotomicPolynomial",
    "DataType",
    "DayDMY",
    "DaysInMonth",
    "DaysInYear",
    "DeclareHandlingByNiceBasis",
    "DeclareInfoClass",
    "DecodeTree",
    "DecomposedFixedPointVector",
    "DecomposeTensorProduct",
    "Decomposition",
    "DecompositionInt",
    "DecompositionMatrix",
    "Decreased",
    "DefaultField",
    "DefaultFieldByGenerators",
    "DefaultFieldOfMatrix",
    "DefaultFieldOfMatrixGroup",
    "DefaultRing",
    "DefaultRingByGenerators",
    "DefiningPolynomial",
    "DefiningQuotientHomomorphism",
    "DegreeFFE",
    "DegreeIndeterminate",
    "DegreeOfBinaryRelation",
    "DegreeOfCharacter",
    "DegreeOfLaurentPolynomial",
    "DegreeOfTransformation",
    "DegreeOfTransformationSemigroup",
    "DegreeOverPrimeField",
    "Delta",
    "DenominatorCyc",
    "DenominatorOfModuloPcgs",
    "DenominatorOfRationalFunction",
    "DenominatorRat",
    "DepthOfPcElement",
    "DepthOfUpperTriangularMatrix",
    "Derangements",
    "Derivations",
    "Derivative",
    "DerivedLength",
    "DerivedSeriesOfGroup",
    "DerivedSubgroup",
    "DerivedSubgroupsTom",
    "DerivedSubgroupsTomPossible",
    "DerivedSubgroupsTomUnique",
    "DerivedSubgroupTom",
    "DescriptionOfRootOfUnity",
    "Determinant",
    "DeterminantIntMat",
    "DeterminantMat",
    "DeterminantMatDestructive",
    "DeterminantMatDivFree",
    "DeterminantOfCharacter",
    "DiagonalizeIntMat",
    "DiagonalizeMat",
    "DiagonalMat",
    "DiagonalOfMat",
    "Difference",
    "DifferenceBlist",
    "DihedralGroup",
    "Dimension",
    "DimensionOfHighestWeightModule",
    "DimensionOfMatrixGroup",
    "DimensionOfVectors",
    "DimensionsLoewyFactors",
    "DimensionsMat",
    "DirectoriesLibrary",
    "DirectoriesPackageLibrary",
    "DirectoriesPackagePrograms",
    "DirectoriesSystemPrograms",
    "Directory",
    "DirectoryContents",
    "DirectoryCurrent",
    "DirectoryTemporary",
    "DirectProduct",
    "DirectProductOp",
    "DirectSumDecomposition",
    "DirectSumOfAlgebraModules",
    "DirectSumOfAlgebras",
    "DisableAttributeValueStoring",
    "Discriminant",
    "Display",
    "DisplayCacheStats",
    "DisplayCompositionSeries",
    "DisplayEggBoxOfDClass",
    "DisplayImfInvariants",
    "DisplayInformationPerfectGroups",
    "DisplayOptions",
    "DisplayOptionsStack",
    "DisplayProfile",
    "DisplayRevision",
    "DistancesDistributionMatFFEVecFFE",
    "DistancesDistributionVecFFEsVecFFE",
    "DistanceVecFFE",
    "DivisionRingByGenerators",
    "DivisorsInt",
    "DixonInit",
    "DixonRecord",
    "DixonSplit",
    "DixontinI",
    "DMYDay",
    "DMYhmsSeconds",
    "DnLattice",
    "DnLatticeIterative",
    "Domain",
    "DomainByGenerators",
    "DominantCharacter",
    "DominantWeights",
    "DoubleCoset",
    "DoubleCosetRepsAndSizes",
    "DoubleCosets",
    "DoubleCosetsNC",
    "DownEnv",
    "DuplicateFreeList",
    "DxIncludeIrreducibles",
    "E",
    "EANormalSeriesByPcgs",
    "Earns",
    "EB",
    "EC",
    "ED",
    "Edit",
    "EE",
    "EF",
    "EG",
    "EggBoxOfDClass",
    "EH",
    "EI",
    "Eigenspaces",
    "Eigenvalues",
    "EigenvaluesChar",
    "Eigenvectors",
    "EJ",
    "EK",
    "EL",
    "ElementaryAbelianGroup",
    "ElementaryAbelianSeries",
    "ElementaryAbelianSeriesLargeSteps",
    "ElementaryDivisorsMat",
    "ElementaryDivisorsMatDestructive",
    "ElementOfFpGroup",
    "ElementOfFpSemigroup",
    "ElementOfMagmaRing",
    "ElementOrdersPowerMap",
    "ElementProperty",
    "Elements",
    "ElementsFamily",
    "ElementsStabChain",
    "EliminatedWord",
    "EliminationOrdering",
    "EM",
    "Embedding",
    "EmptyBinaryRelation",
    "EmptyMatrix",
    "EmptyPlist",
    "EmptySCTable",
    "EmptyStabChain",
    "EmptyString",
    "EnableAttributeValueStoring",
    "End",
    "Enumerator",
    "EnumeratorByBasis",
    "EnumeratorByFunctions",
    "EnumeratorSorted",
    "Epicentre",
    "EpimorphismFromFreeGroup",
    "EpimorphismNilpotentQuotient",
    "EpimorphismNonabelianExteriorSquare",
    "EpimorphismPGroup",
    "EpimorphismQuotientSystem",
    "EpimorphismSchurCover",
    "EquivalenceClasses",
    "EquivalenceClassOfElement",
    "EquivalenceClassOfElementNC",
    "EquivalenceClassRelation",
    "EquivalenceRelationByPairs",
    "EquivalenceRelationByPairsNC",
    "EquivalenceRelationByPartition",
    "EquivalenceRelationByPartitionNC",
    "EquivalenceRelationByProperty",
    "EquivalenceRelationByRelation",
    "EquivalenceRelationPartition",
    "ER",
    "Error",
    "ErrorCount",
    "ES",
    "ET",
    "EU",
    "EuclideanDegree",
    "EuclideanQuotient",
    "EuclideanRemainder",
    "EulerianFunction",
    "EulerianFunctionByTom",
    "EV",
    "EvalStraightLineProgElm",
    "EvalString",
    "EW",
    "EX",
    "ExactSizeConsiderFunction",
    "Exec",
    "Exponent",
    "ExponentOfPcElement",
    "ExponentsConjugateLayer",
    "ExponentsOfCommutator",
    "ExponentsOfConjugate",
    "ExponentsOfPcElement",
    "ExponentsOfRelativePower",
    "ExponentSumWord",
    "ExponentSyllable",
    "ExtendedPcgs",
    "ExtendStabChain",
    "Extension",
    "ExtensionNC",
    "ExtensionRepresentatives",
    "Extensions",
    "ExteriorCentre",
    "ExteriorPowerOfAlgebraModule",
    "ExternalOrbit",
    "ExternalOrbits",
    "ExternalOrbitsStabilizers",
    "ExternalSet",
    "ExternalSubset",
    "Extract",
    "ExtraspecialGroup",
    "ExtRepDenominatorRatFun",
    "ExtRepNumeratorRatFun",
    "ExtRepOfObj",
    "ExtRepPolynomialRatFun",
    "EY",
    "FactorCosetAction",
    "FactorCosetOperation",
    "FactorFreeSemigroupByRelations",
    "FactorGroup",
    "FactorGroupFpGroupByRels",
    "FactorGroupNC",
    "FactorGroupNormalSubgroupClasses",
    "FactorGroupTom",
    "Factorial",
    "Factorization",
    "Factors",
    "FactorsInt",
    "FactorsOfDirectProduct",
    "FactorsSquarefree",
    "FaithfulModule",
    "FamiliesOfGeneralMappingsAndRanges",
    "FamiliesOfRows",
    "FamilyForOrdering",
    "FamilyObj",
    "FamilyPcgs",
    "FamilyRange",
    "FamilySource",
    "Fibonacci",
    "Field",
    "FieldExtension",
    "FieldOfMatrixGroup",
    "FieldOverItselfByGenerators",
    "FileDescriptorOfStream",
    "Filename",
    "Filtered",
    "FindSl2",
    "First",
    "FittingSubgroup",
    "Flat",
    "ForAll",
    "ForAny",
    "FpElmComparisonMethod",
    "FpGroupPresentation",
    "FpGrpMonSmgOfFpGrpMonSmgElement",
    "FpLieAlgebraByCartanMatrix",
    "FrattiniSubgroup",
    "FreeAlgebra",
    "FreeAlgebraWithOne",
    "FreeAssociativeAlgebra",
    "FreeAssociativeAlgebraWithOne",
    "FreeGeneratorsOfFpGroup",
    "FreeGeneratorsOfFpSemigroup",
    "FreeGeneratorsOfWholeGroup",
    "FreeGroup",
    "FreeGroupOfFpGroup",
    "FreeLeftModule",
    "FreeLieAlgebra",
    "FreeMagma",
    "FreeMagmaRing",
    "FreeMagmaWithOne",
    "FreeMonoid",
    "FreeMonoidOfRewritingSystem",
    "FreeProduct",
    "FreeSemigroup",
    "FreeSemigroupOfFpSemigroup",
    "FreeSemigroupOfRewritingSystem",
    "FrobeniusAutomorphism",
    "FrobeniusCharacterValue",
    "FullMatrixAlgebra",
    "FullMatrixAlgebraCentralizer",
    "FullMatrixLieAlgebra",
    "FullMatrixModule",
    "FullMatrixSpace",
    "FullRowModule",
    "FullRowSpace",
    "FullTransformationSemigroup",
    "function",
    "FunctionAction",
    "FusionCharTableTom",
    "FusionConjugacyClasses",
    "FusionConjugacyClassesOp",
    "FusionsAllowedByRestrictions",
    "FusionsTom",
    "GaloisCyc",
    "GaloisField",
    "GaloisGroup",
    "GaloisMat",
    "GaloisStabilizer",
    "GaloisType",
    "Gap3CatalogueIdGroup",
    "GapInputPcGroup",
    "GapInputSCTable",
    "GasmanLimits",
    "GasmanMessageStatus",
    "GasmanStatistics",
    "Gcd",
    "Gcdex",
    "GcdInt",
    "GcdOp",
    "GcdRepresentation",
    "GcdRepresentationOp",
    "GeneralisedEigenspaces",
    "GeneralisedEigenvalues",
    "GeneralizedEigenspaces",
    "GeneralizedEigenvalues",
    "GeneralLinearGroup",
    "GeneralMappingByElements",
    "GeneralMappingsFamily",
    "GeneralOrthogonalGroup",
    "GeneralUnitaryGroup",
    "GeneratorsOfAdditiveGroup",
    "GeneratorsOfAdditiveMagma",
    "GeneratorsOfAdditiveMagmaWithZero",
    "GeneratorsOfAlgebra",
    "GeneratorsOfAlgebraModule",
    "GeneratorsOfAlgebraWithOne",
    "GeneratorsOfDivisionRing",
    "GeneratorsOfDomain",
    "GeneratorsOfEquivalenceRelationPartition",
    "GeneratorsOfField",
    "GeneratorsOfGroup",
    "GeneratorsOfIdeal",
    "GeneratorsOfLeftIdeal",
    "GeneratorsOfLeftModule",
    "GeneratorsOfLeftOperatorAdditiveGroup",
    "GeneratorsOfLeftVectorSpace",
    "GeneratorsOfMagma",
    "GeneratorsOfMagmaWithInverses",
    "GeneratorsOfMagmaWithOne",
    "GeneratorsOfMonoid",
    "GeneratorsOfNearAdditiveGroup",
    "GeneratorsOfNearAdditiveMagma",
    "GeneratorsOfNearAdditiveMagmaWithZero",
    "GeneratorsOfPresentation",
    "GeneratorsOfRightIdeal",
    "GeneratorsOfRightModule",
    "GeneratorsOfRightOperatorAdditiveGroup",
    "GeneratorsOfRing",
    "GeneratorsOfRingWithOne",
    "GeneratorsOfRws",
    "GeneratorsOfSemigroup",
    "GeneratorsOfTwoSidedIdeal",
    "GeneratorsOfVectorSpace",
    "GeneratorsPrimeResidues",
    "GeneratorsSmallest",
    "GeneratorsSubgroupsTom",
    "GeneratorSyllable",
    "GetFusionMap",
    "GF",
    "GL",
    "GModuleByMats",
    "GO",
    "GQuotients",
    "Grading",
    "GreensDClasses",
    "GreensDClassOfElement",
    "GreensDRelation",
    "GreensHClasses",
    "GreensHClassOfElement",
    "GreensHRelation",
    "GreensJClasses",
    "GreensJClassOfElement",
    "GreensJRelation",
    "GreensLClasses",
    "GreensLClassOfElement",
    "GreensLRelation",
    "GreensRClasses",
    "GreensRClassOfElement",
    "GreensRRelation",
    "GroebnerBasis",
    "GroebnerBasisNC",
    "Group",
    "GroupByRws",
    "GroupByRwsNC",
    "GroupGeneralMappingByImages",
    "GroupHClassOfGreensDClass",
    "GroupHomomorphismByFunction",
    "GroupHomomorphismByImages",
    "GroupHomomorphismByImagesNC",
    "GroupOfPcgs",
    "GroupRing",
    "GroupStabChain",
    "GroupWithGenerators",
    "GU",
    "HallSubgroup",
    "HallSystem",
    "HasAbelianFactorGroup",
    "HasElementaryAbelianFactorGroup",
    "HasIndeterminateName",
    "HasParent",
    "HasseDiagramBinaryRelation",
    "HeadPcElementByNumber",
    "HenselBound",
    "HermiteNormalFormIntegerMat",
    "HermiteNormalFormIntegerMatTransform",
    "HeuristicCancelPolynomials",
    "HexStringInt",
    "HighestWeightModule",
    "HMSMSec",
    "Hom",
    "HomeEnumerator",
    "HomomorphismQuotientSemigroup",
    "HomomorphismTransformationSemigroup",
    "HumanReadableDefinition",
    "Ideal",
    "IdealByGenerators",
    "IdealNC",
    "Idempotents",
    "IdempotentsTom",
    "IdempotentsTomInfo",
    "IdentificationOfConjugacyClasses",
    "Identifier",
    "Identity",
    "IdentityBinaryRelation",
    "IdentityFromSCTable",
    "IdentityMapping",
    "IdentityMat",
    "IdentityTransformation",
    "IdFunc",
    "IdGap3SolvableGroup",
    "IdGroup",
    "IdSmallGroup",
    "IdsOfAllSmallGroups",
    "Image",
    "ImageElm",
    "ImageListOfTransformation",
    "Images",
    "ImagesElm",
    "ImageSetOfTransformation",
    "ImagesRepresentative",
    "ImagesSet",
    "ImagesSmallestGenerators",
    "ImagesSource",
    "ImaginaryPart",
    "ImfInvariants",
    "ImfMatrixGroup",
    "ImfNumberQClasses",
    "ImfNumberQQClasses",
    "ImfNumberZClasses",
    "Immutable",
    "ImmutableBasis",
    "ImmutableMatrix",
    "IndependentGeneratorsOfAbelianGroup",
    "Indeterminate",
    "IndeterminateName",
    "Indeterminateness",
    "IndeterminateNumberOfLaurentPolynomial",
    "IndeterminateNumberOfUnivariateRationalFunction",
    "IndeterminateOfUnivariateRationalFunction",
    "IndeterminatesOfPolynomialRing",
    "Index",
    "IndexInWholeGroup",
    "IndexNC",
    "Indicator",
    "IndicatorOp",
    "IndicesCentralNormalSteps",
    "IndicesChiefNormalSteps",
    "IndicesEANormalSteps",
    "IndicesInvolutaryGenerators",
    "IndicesNormalSteps",
    "IndicesOfAdjointBasis",
    "IndicesPCentralNormalStepsPGroup",
    "IndicesStabChain",
    "Indirected",
    "InducedAutomorphism",
    "InducedClassFunction",
    "InducedClassFunctions",
    "InducedClassFunctionsByFusionMap",
    "InducedCyclic",
    "InducedPcgs",
    "InducedPcgsByGenerators",
    "InducedPcgsByGeneratorsNC",
    "InducedPcgsByPcSequence",
    "InducedPcgsByPcSequenceAndGenerators",
    "InducedPcgsByPcSequenceNC",
    "InducedPcgsWrtFamilyPcgs",
    "InducedPcgsWrtSpecialPcgs",
    "Inequalities",
    "InertiaSubgroup",
    "Info",
    "InfoLevel",
    "InfoText",
    "Init",
    "InitFusion",
    "InitPowerMap",
    "InjectionZeroMagma",
    "InnerAutomorphism",
    "InnerAutomorphismNC",
    "InnerAutomorphismsAutomorphismGroup",
    "InputLogTo",
    "InputOutputLocalProcess",
    "InputTextFile",
    "InputTextNone",
    "InputTextString",
    "InputTextUser",
    "InsertTrivialStabilizer",
    "InstallAtExit",
    "InstallCharReadHookFunc",
    "InstalledPackageVersion",
    "InstallFactorMaintenance",
    "InstallHandlingByNiceBasis",
    "InstallIsomorphismMaintenance",
    "InstallSubsetMaintenance",
    "Int",
    "INT_CHAR",
    "IntegralizedMat",
    "IntegratedStraightLineProgram",
    "IntermediateGroup",
    "IntermediateResultOfSLP",
    "IntermediateResultOfSLPWithoutOverwrite",
    "IntermediateResultsOfSLPWithoutOverwrite",
    "IntermediateSubgroups",
    "InterpolatedPolynomial",
    "IntersectBlist",
    "Intersection",
    "Intersection2",
    "IntersectionBlist",
    "IntersectionsTom",
    "IntersectSet",
    "IntFFE",
    "IntFFESymm",
    "IntHexString",
    "IntScalarProducts",
    "IntVecFFE",
    "InvariantBilinearForm",
    "InvariantElementaryAbelianSeries",
    "InvariantLattice",
    "InvariantQuadraticForm",
    "InvariantSesquilinearForm",
    "InvariantSubgroupsElementaryAbelianGroup",
    "Inverse",
    "InverseAttr",
    "InverseClasses",
    "InverseGeneralMapping",
    "InverseImmutable",
    "InverseMap",
    "InverseMatMod",
    "InverseMutable",
    "InverseOp",
    "InverseRepresentative",
    "InverseSameMutability",
    "InverseSM",
    "Irr",
    "IrrBaumClausen",
    "IrrConlon",
    "IrrDixonSchneider",
    "IrreducibleDifferences",
    "IrreducibleModules",
    "IrreducibleRepresentations",
    "IrreducibleRepresentationsDixon",
    "IrreducibleSolvableGroup",
    "IrreducibleSolvableGroupMS",
    "Is16BitsFamily",
    "Is32BitsFamily",
    "Is8BitsFamily",
    "IsAbelian",
    "IsAbelianNumberField",
    "IsAbelianNumberFieldPolynomialRing",
    "IsAbelianTom",
    "IsAdditiveElement",
    "IsAdditiveElementWithInverse",
    "IsAdditiveElementWithZero",
    "IsAdditiveGroup",
    "IsAdditiveGroupGeneralMapping",
    "IsAdditiveGroupHomomorphism",
    "IsAdditivelyCommutative",
    "IsAdditivelyCommutativeElement",
    "IsAdditivelyCommutativeElementCollColl",
    "IsAdditivelyCommutativeElementCollection",
    "IsAdditivelyCommutativeElementFamily",
    "IsAdditiveMagma",
    "IsAdditiveMagmaWithInverses",
    "IsAdditiveMagmaWithZero",
    "IsAlgebra",
    "IsAlgebraGeneralMapping",
    "IsAlgebraHomomorphism",
    "IsAlgebraicElement",
    "IsAlgebraicExtension",
    "IsAlgebraModuleElement",
    "IsAlgebraModuleElementCollection",
    "IsAlgebraModuleElementFamily",
    "IsAlgebraWithOne",
    "IsAlgebraWithOneGeneralMapping",
    "IsAlgebraWithOneHomomorphism",
    "IsAlphaChar",
    "IsAlternatingGroup",
    "IsAnticommutative",
    "IsAntisymmetricBinaryRelation",
    "IsAssociated",
    "IsAssociative",
    "IsAssociativeElement",
    "IsAssociativeElementCollColl",
    "IsAssociativeElementCollection",
    "IsAssocWord",
    "IsAssocWordWithInverse",
    "IsAssocWordWithOne",
    "IsAutomorphismGroup",
    "IsBasicWreathLessThanOrEqual",
    "IsBasicWreathProductOrdering",
    "IsBasis",
    "IsBasisByNiceBasis",
    "IsBasisOfAlgebraModuleElementSpace",
    "IsBergerCondition",
    "IsBijective",
    "IsBinaryRelation",
    "IsBLetterAssocWordRep",
    "IsBLetterWordsFamily",
    "IsBlist",
    "IsBool",
    "IsBound",
    "IsBoundGlobal",
    "IsBrauerTable",
    "IsBravaisGroup",
    "IsBuiltFromAdditiveMagmaWithInverses",
    "IsBuiltFromGroup",
    "IsBuiltFromMagma",
    "IsBuiltFromMagmaWithInverses",
    "IsBuiltFromMagmaWithOne",
    "IsBuiltFromSemigroup",
    "IsCanonicalBasis",
    "IsCanonicalBasisFullMatrixModule",
    "IsCanonicalBasisFullRowModule",
    "IsCanonicalNiceMonomorphism",
    "IsCanonicalPcgs",
    "IsCentral",
    "IsCentralFactor",
    "IsChar",
    "IsCharacter",
    "IsCharacteristicSubgroup",
    "IsCharacterTable",
    "IsCharacterTableInProgress",
    "IsCharCollection",
    "IsCheapConwayPolynomial",
    "IsClassFunction",
    "IsClassFusionOfNormalSubgroup",
    "IsClosedStream",
    "IsCochain",
    "IsCochainCollection",
    "IsCollection",
    "IsCollectionFamily",
    "IsCommutative",
    "IsCommutativeElement",
    "IsCommutativeElementCollColl",
    "IsCommutativeElementCollection",
    "IsCompositionMappingRep",
    "IsConfluent",
    "IsConjugacyClassSubgroupsByStabilizerRep",
    "IsConjugacyClassSubgroupsRep",
    "IsConjugate",
    "IsConjugatorAutomorphism",
    "IsConjugatorIsomorphism",
    "IsConstantRationalFunction",
    "IsConstantTimeAccessGeneralMapping",
    "IsConstantTimeAccessList",
    "IsContainedInSpan",
    "IsCopyable",
    "IsCyc",
    "IsCyclic",
    "IsCyclicTom",
    "IsCyclotomic",
    "IsCyclotomicField",
    "IsCyclotomicMatrixGroup",
    "IsDenseList",
    "IsDiagonalMat",
    "IsDigitChar",
    "IsDirectoryPath",
    "IsDistributive",
    "IsDivisionRing",
    "IsDomain",
    "IsDoneIterator",
    "IsDoubleCoset",
    "IsDuplicateFree",
    "IsDuplicateFreeList",
    "IsDxLargeGroup",
    "IsElementaryAbelian",
    "IsElementOfFpMonoid",
    "IsElementOfFpSemigroup",
    "IsElementOfFreeMagmaRing",
    "IsElementOfFreeMagmaRingCollection",
    "IsElementOfFreeMagmaRingFamily",
    "IsElementOfMagmaRingModuloRelations",
    "IsElementOfMagmaRingModuloRelationsCollection",
    "IsElementOfMagmaRingModuloRelationsFamily",
    "IsElementOfMagmaRingModuloSpanOfZeroFamily",
    "IsEmpty",
    "IsEmptyString",
    "IsEndOfStream",
    "IsEndoGeneralMapping",
    "IsEqualSet",
    "IsEquivalenceClass",
    "IsEquivalenceRelation",
    "IsEuclideanRing",
    "IsEvenInt",
    "IsExecutableFile",
    "IsExistingFile",
    "IsExtAElement",
    "IsExternalOrbit",
    "IsExternalSet",
    "IsExternalSubset",
    "IsExtLElement",
    "IsExtRElement",
    "IsFamilyPcgs",
    "IsFFE",
    "IsFFECollColl",
    "IsFFECollection",
    "IsField",
    "IsFieldHomomorphism",
    "IsFinite",
    "IsFiniteDimensional",
    "IsFiniteFieldPolynomialRing",
    "IsFinitelyGeneratedGroup",
    "IsFiniteOrderElement",
    "IsFiniteOrderElementCollColl",
    "IsFiniteOrderElementCollection",
    "IsFiniteOrdersPcgs",
    "IsFixedStabilizer",
    "IsFLMLOR",
    "IsFLMLORWithOne",
    "IsFpGroup",
    "IsFpMonoid",
    "IsFpSemigroup",
    "IsFreeGroup",
    "IsFreeLeftModule",
    "IsFreeMagmaRing",
    "IsFreeMagmaRingWithOne",
    "IsFromFpGroupGeneralMappingByImages",
    "IsFromFpGroupHomomorphismByImages",
    "IsFromFpGroupStdGensGeneralMappingByImages",
    "IsFromFpGroupStdGensHomomorphismByImages",
    "IsFullHomModule",
    "IsFullMatrixModule",
    "IsFullRowModule",
    "IsFullSubgroupGLorSLRespectingBilinearForm",
    "IsFullSubgroupGLorSLRespectingQuadraticForm",
    "IsFullSubgroupGLorSLRespectingSesquilinearForm",
    "IsFullTransformationSemigroup",
    "IsFunction",
    "IsGAPRandomSource",
    "IsGaussianIntegers",
    "IsGaussianRationals",
    "IsGaussianSpace",
    "IsGaussInt",
    "IsGaussRat",
    "IsGeneralizedDomain",
    "IsGeneralizedRowVector",
    "IsGeneralLinearGroup",
    "IsGeneralMapping",
    "IsGeneralMappingFamily",
    "IsGL",
    "IsGlobalRandomSource",
    "IsGreensClass",
    "IsGreensDClass",
    "IsGreensDRelation",
    "IsGreensHClass",
    "IsGreensHRelation",
    "IsGreensJClass",
    "IsGreensJRelation",
    "IsGreensLClass",
    "IsGreensLessThanOrEqual",
    "IsGreensLRelation",
    "IsGreensRClass",
    "IsGreensRelation",
    "IsGreensRRelation",
    "IsGroup",
    "IsGroupGeneralMapping",
    "IsGroupGeneralMappingByAsGroupGeneralMappingByImages",
    "IsGroupGeneralMappingByImages",
    "IsGroupGeneralMappingByPcgs",
    "IsGroupHClass",
    "IsGroupHomomorphism",
    "IsGroupOfAutomorphisms",
    "IsGroupRing",
    "IsHandledByNiceBasis",
    "IsHandledByNiceMonomorphism",
    "IsHasseDiagram",
    "IsHomogeneousList",
    "IsIdempotent",
    "IsIdenticalObj",
    "IsIncomparableUnder",
    "IsInducedFromNormalSubgroup",
    "IsInducedPcgs",
    "IsInducedPcgsWrtSpecialPcgs",
    "IsInfBitsFamily",
    "IsInfinity",
    "IsInjective",
    "IsInnerAutomorphism",
    "IsInputOutputStream",
    "IsInputStream",
    "IsInputTextNone",
    "IsInputTextStream",
    "IsInt",
    "IsIntegerMatrixGroup",
    "IsIntegers",
    "IsIntegralBasis",
    "IsIntegralCyclotomic",
    "IsIntegralRing",
    "IsInternallyConsistent",
    "IsIrreducibleCharacter",
    "IsIrreducibleRingElement",
    "IsIterator",
    "IsJacobianElement",
    "IsJacobianElementCollColl",
    "IsJacobianElementCollection",
    "IsJacobianRing",
    "IsLaurentPolynomial",
    "IsLaurentPolynomialDefaultRep",
    "IsLDistributive",
    "IsLeftAlgebraModuleElement",
    "IsLeftAlgebraModuleElementCollection",
    "IsLeftIdeal",
    "IsLeftIdealInParent",
    "IsLeftModule",
    "IsLeftModuleGeneralMapping",
    "IsLeftModuleHomomorphism",
    "IsLeftOperatorAdditiveGroup",
    "IsLeftSemigroupIdeal",
    "IsLeftVectorSpace",
    "IsLessThanOrEqualUnder",
    "IsLessThanUnder",
    "IsLetterAssocWordRep",
    "IsLetterWordsFamily",
    "IsLexicographicallyLess",
    "IsLexOrderedFFE",
    "IsLieAbelian",
    "IsLieAlgebra",
    "IsLieMatrix",
    "IsLieNilpotent",
    "IsLieObject",
    "IsLieObjectCollection",
    "IsLieSolvable",
    "IsLinearMapping",
    "IsLinearMappingsModule",
    "IsList",
    "IsListDefault",
    "IsListOrCollection",
    "IsLogOrderedFFE",
    "IsLowerAlphaChar",
    "IsLowerTriangularMat",
    "IsMagma",
    "IsMagmaHomomorphism",
    "IsMagmaRingModuloRelations",
    "IsMagmaRingModuloSpanOfZero",
    "IsMagmaWithInverses",
    "IsMagmaWithInversesIfNonzero",
    "IsMagmaWithOne",
    "IsMapping",
    "IsMatchingSublist",
    "IsMatrix",
    "IsMatrixGroup",
    "IsMatrixModule",
    "IsMatrixSpace",
    "IsMersenneTwister",
    "IsMinimalNonmonomial",
    "IsModuloPcgs",
    "IsMonoid",
    "IsMonomialGroup",
    "IsMonomialMatrix",
    "IsMonomialNumber",
    "IsMonomialOrdering",
    "IsMultiplicativeElement",
    "IsMultiplicativeElementWithInverse",
    "IsMultiplicativeElementWithOne",
    "IsMultiplicativeElementWithZero",
    "IsMultiplicativeGeneralizedRowVector",
    "IsMultiplicativeZero",
    "IsMutable",
    "IsMutableBasis",
    "IsNaturalAlternatingGroup",
    "IsNaturalGL",
    "IsNaturalGLnZ",
    "IsNaturalSL",
    "IsNaturalSLnZ",
    "IsNaturalSymmetricGroup",
    "IsNearAdditiveElement",
    "IsNearAdditiveElementWithInverse",
    "IsNearAdditiveElementWithZero",
    "IsNearAdditiveGroup",
    "IsNearAdditiveMagma",
    "IsNearAdditiveMagmaWithInverses",
    "IsNearAdditiveMagmaWithZero",
    "IsNearlyCharacterTable",
    "IsNearRingElement",
    "IsNearRingElementWithInverse",
    "IsNearRingElementWithOne",
    "IsNegRat",
    "IsNilpotentElement",
    "IsNilpotentGroup",
    "IsNilpotentTom",
    "IsNonassocWord",
    "IsNonassocWordCollection",
    "IsNonassocWordWithOne",
    "IsNonassocWordWithOneCollection",
    "IsNonnegativeIntegers",
    "IsNonSPGeneralMapping",
    "IsNonTrivial",
    "IsNormal",
    "IsNormalBasis",
    "IsNotIdenticalObj",
    "IsNumberField",
    "IsObject",
    "IsOddInt",
    "IsomorphicSubgroups",
    "IsomorphismFpAlgebra",
    "IsomorphismFpGroup",
    "IsomorphismFpGroupByGenerators",
    "IsomorphismFpGroupByGeneratorsNC",
    "IsomorphismFpGroupByPcgs",
    "IsomorphismFpSemigroup",
    "IsomorphismGroups",
    "IsomorphismMatrixAlgebra",
    "IsomorphismPcGroup",
    "IsomorphismPermGroup",
    "IsomorphismPermGroupImfGroup",
    "IsomorphismReesMatrixSemigroup",
    "IsomorphismRefinedPcGroup",
    "IsomorphismSCAlgebra",
    "IsomorphismSimplifiedFpGroup",
    "IsomorphismSpecialPcGroup",
    "IsomorphismTransformationSemigroup",
    "IsomorphismTypeInfoFiniteSimpleGroup",
    "IsOne",
    "IsOperation",
    "IsOrdering",
    "IsOrderingOnFamilyOfAssocWords",
    "IsOrdinaryMatrix",
    "IsOrdinaryTable",
    "IsOutputStream",
    "IsOutputTextNone",
    "IsOutputTextStream",
    "IsPadicExtensionNumber",
    "IsPadicExtensionNumberFamily",
    "IsParentPcgsFamilyPcgs",
    "IsPartialOrderBinaryRelation",
    "IsPcGroup",
    "IsPcGroupGeneralMappingByImages",
    "IsPcGroupHomomorphismByImages",
    "IsPcgs",
    "IsPcgsCentralSeries",
    "IsPcgsChiefSeries",
    "IsPcgsElementaryAbelianSeries",
    "IsPcgsPCentralSeriesPGroup",
    "IsPerfectGroup",
    "IsPerfectTom",
    "IsPerm",
    "IsPermCollColl",
    "IsPermCollection",
    "IsPermGroup",
    "IsPermGroupGeneralMappingByImages",
    "IsPermGroupHomomorphismByImages",
    "IsPGroup",
    "IsPNilpotent",
    "IsPolycyclicGroup",
    "IsPolynomial",
    "IsPolynomialDefaultRep",
    "IsPolynomialFunction",
    "IsPolynomialFunctionsFamily",
    "IsPolynomialRing",
    "IsPosInt",
    "IsPositiveIntegers",
    "IsPosRat",
    "IsPreimagesByAsGroupGeneralMappingByImages",
    "IsPreOrderBinaryRelation",
    "IsPrime",
    "IsPrimeField",
    "IsPrimeInt",
    "IsPrimeOrdersPcgs",
    "IsPrimePowerInt",
    "IsPrimitive",
    "IsPrimitiveCharacter",
    "IsPrimitivePolynomial",
    "IsPrimitiveRootMod",
    "IsProbablyPrimeInt",
    "IsPseudoCanonicalBasisFullHomModule",
    "IsPSolvable",
    "IsPSolvableCharacterTable",
    "IsPSolvableCharacterTableOp",
    "IsPurePadicNumber",
    "IsPurePadicNumberFamily",
    "IsQuasiPrimitive",
    "IsQuaternion",
    "IsQuaternionCollColl",
    "IsQuaternionCollection",
    "IsQuickPositionList",
    "IsQuotientSemigroup",
    "IsRandomSource",
    "IsRange",
    "IsRat",
    "IsRationalFunction",
    "IsRationalFunctionDefaultRep",
    "IsRationalFunctionsFamily",
    "IsRationalMatrixGroup",
    "IsRationals",
    "IsRationalsPolynomialRing",
    "IsRDistributive",
    "IsReadableFile",
    "IsReadOnlyGlobal",
    "IsRecord",
    "IsRecordCollColl",
    "IsRecordCollection",
    "IsReduced",
    "IsReductionOrdering",
    "IsReesCongruence",
    "IsReesCongruenceSemigroup",
    "IsReesMatrixSemigroup",
    "IsReesMatrixSemigroupElement",
    "IsReesZeroMatrixSemigroup",
    "IsReesZeroMatrixSemigroupElement",
    "IsReflexiveBinaryRelation",
    "IsRegular",
    "IsRegularDClass",
    "IsRegularSemigroup",
    "IsRegularSemigroupElement",
    "IsRelativelySM",
    "IsRestrictedLieAlgebra",
    "IsRewritingSystem",
    "IsRightAlgebraModuleElement",
    "IsRightAlgebraModuleElementCollection",
    "IsRightCoset",
    "IsRightIdeal",
    "IsRightIdealInParent",
    "IsRightModule",
    "IsRightOperatorAdditiveGroup",
    "IsRightSemigroupIdeal",
    "IsRing",
    "IsRingElement",
    "IsRingElementWithInverse",
    "IsRingElementWithOne",
    "IsRingGeneralMapping",
    "IsRingHomomorphism",
    "IsRingWithOne",
    "IsRingWithOneGeneralMapping",
    "IsRingWithOneHomomorphism",
    "IsRootSystem",
    "IsRootSystemFromLieAlgebra",
    "IsRowModule",
    "IsRowSpace",
    "IsRowVector",
    "IsScalar",
    "IsSemiEchelonized",
    "IsSemigroup",
    "IsSemigroupCongruence",
    "IsSemigroupIdeal",
    "IsSemiRegular",
    "IsSet",
    "IsShortLexLessThanOrEqual",
    "IsShortLexOrdering",
    "IsSimpleAlgebra",
    "IsSimpleGroup",
    "IsSimpleSemigroup",
    "IsSingleValued",
    "IsSL",
    "IsSolvableGroup",
    "IsSolvableTom",
    "IsSortedList",
    "IsSpecialLinearGroup",
    "IsSpecialPcgs",
    "IsSPGeneralMapping",
    "IsSSortedList",
    "IsStandardGeneratorsOfGroup",
    "IsStraightLineProgElm",
    "IsStraightLineProgram",
    "IsStream",
    "IsString",
    "IsStringRep",
    "IsSubgroup",
    "IsSubgroupFpGroup",
    "IsSubgroupOfWholeGroupByQuotientRep",
    "IsSubgroupSL",
    "IsSubmonoidFpMonoid",
    "IsSubnormal",
    "IsSubnormallyMonomial",
    "IsSubsemigroupFpSemigroup",
    "IsSubset",
    "IsSubsetBlist",
    "IsSubsetLocallyFiniteGroup",
    "IsSubsetSet",
    "IsSubspacesVectorSpace",
    "IsSupersolvableGroup",
    "IsSurjective",
    "IsSyllableAssocWordRep",
    "IsSyllableWordsFamily",
    "IsSymmetricBinaryRelation",
    "IsSymmetricGroup",
    "IsTable",
    "IsTableOfMarks",
    "IsTableOfMarksWithGens",
    "IsToPcGroupGeneralMappingByImages",
    "IsToPcGroupHomomorphismByImages",
    "IsToPermGroupGeneralMappingByImages",
    "IsToPermGroupHomomorphismByImages",
    "IsTotal",
    "IsTotalOrdering",
    "IsTransformation",
    "IsTransformationCollection",
    "IsTransformationMonoid",
    "IsTransformationSemigroup",
    "IsTransitive",
    "IsTransitiveBinaryRelation",
    "IsTranslationInvariantOrdering",
    "IsTrivial",
    "IsTuple",
    "IsTwoSidedIdeal",
    "IsTwoSidedIdealInParent",
    "IsUEALatticeElement",
    "IsUEALatticeElementCollection",
    "IsUEALatticeElementFamily",
    "IsUniqueFactorizationRing",
    "IsUnit",
    "IsUnivariatePolynomial",
    "IsUnivariatePolynomialRing",
    "IsUnivariateRationalFunction",
    "IsUnknown",
    "IsUpperAlphaChar",
    "IsUpperTriangularMat",
    "IsValidIdentifier",
    "IsVector",
    "IsVectorSpace",
    "IsVirtualCharacter",
    "IsWeightLexOrdering",
    "IsWeightRepElement",
    "IsWeightRepElementCollection",
    "IsWeightRepElementFamily",
    "IsWellFoundedOrdering",
    "IsWeylGroup",
    "IsWholeFamily",
    "IsWLetterAssocWordRep",
    "IsWLetterWordsFamily",
    "IsWord",
    "IsWordCollection",
    "IsWordWithInverse",
    "IsWordWithOne",
    "IsWreathProductOrdering",
    "IsWritableFile",
    "IsZero",
    "IsZeroGroup",
    "IsZeroSimpleSemigroup",
    "IsZeroSquaredElement",
    "IsZeroSquaredElementCollColl",
    "IsZeroSquaredElementCollection",
    "IsZeroSquaredRing",
    "IsZmodnZObj",
    "IsZmodnZObjNonprime",
    "IsZmodpZObj",
    "IsZmodpZObjLarge",
    "IsZmodpZObjSmall",
    "Iterated",
    "Iterator",
    "IteratorByBasis",
    "IteratorByFunctions",
    "IteratorList",
    "IteratorSorted",
    "Jacobi",
    "JenningsLieAlgebra",
    "JenningsSeries",
    "JoinEquivalenceRelations",
    "JoinStringsWithSeparator",
    "JordanDecomposition",
    "KappaPerp",
    "KernelOfAdditiveGeneralMapping",
    "KernelOfCharacter",
    "KernelOfMultiplicativeGeneralMapping",
    "KernelOfTransformation",
    "KillingMatrix",
    "KnownAttributesOfObject",
    "KnownPropertiesOfObject",
    "KnownTruePropertiesOfObject",
    "KnowsHowToDecompose",
    "KnuthBendixRewritingSystem",
    "KroneckerProduct",
    "KuKGenerators",
    "Lambda",
    "LargestElementGroup",
    "LargestElementStabChain",
    "LargestMovedPoint",
    "LastSystemError",
    "LaTeXStringDecompositionMatrix",
    "LatticeByCyclicExtension",
    "LatticeGeneratorsInUEA",
    "LatticeSubgroups",
    "LatticeSubgroupsByTom",
    "LaurentPolynomialByCoefficients",
    "LaurentPolynomialByExtRep",
    "LaurentPolynomialByExtRepNC",
    "LClassOfHClass",
    "Lcm",
    "LcmInt",
    "LcmOp",
    "LeadCoeffsIGS",
    "LeadingCoefficient",
    "LeadingCoefficientOfPolynomial",
    "LeadingExponentOfPcElement",
    "LeadingMonomial",
    "LeadingMonomialOfPolynomial",
    "LeadingTermOfPolynomial",
    "LeftActingAlgebra",
    "LeftActingDomain",
    "LeftActingRingOfIdeal",
    "LeftAlgebraModule",
    "LeftAlgebraModuleByGenerators",
    "LeftDerivations",
    "LeftIdeal",
    "LeftIdealByGenerators",
    "LeftIdealNC",
    "LeftModuleByGenerators",
    "LeftModuleByHomomorphismToMatAlg",
    "LeftModuleGeneralMappingByImages",
    "LeftModuleHomomorphismByImages",
    "LeftModuleHomomorphismByImagesNC",
    "LeftModuleHomomorphismByMatrix",
    "LeftQuotient",
    "LeftShiftRowVector",
    "Legendre",
    "Length",
    "LengthsTom",
    "LenstraBase",
    "LessThanFunction",
    "LessThanOrEqualFunction",
    "LetterRepAssocWord",
    "LevelsOfGenerators",
    "LeviMalcevDecomposition",
    "LexicographicOrdering",
    "LGFirst",
    "LGLayers",
    "LGLength",
    "LGWeights",
    "<li><code>TensorProductGModule (</code><var>m1</var><code>,</code><var>m2</var><code>) F</code>",
    "<li><code>WedgeGModule (</code><var>module</var><code>)</code>",
    "LieAlgebra",
    "LieAlgebraByStructureConstants",
    "LieBracket",
    "LieCenter",
    "LieCentralizer",
    "LieCentre",
    "LieCoboundaryOperator",
    "LieDerivedSeries",
    "LieDerivedSubalgebra",
    "LieFamily",
    "LieLowerCentralSeries",
    "LieNilRadical",
    "LieNormalizer",
    "LieObject",
    "LieSolvableRadical",
    "LieUpperCentralSeries",
    "LiftedInducedPcgs",
    "LiftedPcElement",
    "LinearAction",
    "LinearActionLayer",
    "LinearCharacters",
    "LinearCombination",
    "LinearCombinationPcgs",
    "LinearIndependentColumns",
    "LinearOperation",
    "LinearOperationLayer",
    "LinesOfStraightLineProgram",
    "List",
    "ListBlist",
    "ListN",
    "ListPerm",
    "ListStabChain",
    "ListWithIdenticalEntries",
    "ListX",
    "LLL",
    "LLLReducedBasis",
    "LLLReducedGramMat",
    "LoadDynamicModule",
    "LoadPackage",
    "LogFFE",
    "LogInt",
    "LogMod",
    "LogModShanks",
    "LogTo",
    "LongestWeylWordPerm",
    "LowercaseString",
    "LowerCentralSeriesOfGroup",
    "LowIndexSubgroupsFpGroup",
    "LowIndexSubgroupsFpGroupIterator",
    "Lucas",
    "Magma",
    "MagmaByGenerators",
    "MagmaByMultiplicationTable",
    "MagmaElement",
    "MagmaHomomorphismByFunctionNC",
    "MagmaRingModuloSpanOfZero",
    "MagmaWithInverses",
    "MagmaWithInversesByGenerators",
    "MagmaWithInversesByMultiplicationTable",
    "MagmaWithOne",
    "MagmaWithOneByGenerators",
    "MagmaWithOneByMultiplicationTable",
    "MakeConfluent",
    "MakeImmutable",
    "MakeReadOnlyGlobal",
    "MakeReadWriteGlobal",
    "MappedWord",
    "MappingByFunction",
    "MappingPermListList",
    "MarksTom",
    "MatAlgebra",
    "MatClassMultCoeffsCharTable",
    "MathieuGroup",
    "MatLieAlgebra",
    "MatrixAlgebra",
    "MatrixAutomorphisms",
    "MatrixByBlockMatrix",
    "MatrixLieAlgebra",
    "MatrixOfAction",
    "MatScalarProducts",
    "MatTom",
    "MaximalAbelianQuotient",
    "MaximalBlocks",
    "MaximalNormalSubgroups",
    "MaximalSubgroupClassReps",
    "MaximalSubgroups",
    "MaximalSubgroupsLattice",
    "MaximalSubgroupsTom",
    "Maximum",
    "MaximumList",
    "MeetEquivalenceRelations",
    "MeetMaps",
    "MemoryUsage",
    "MinimalElementCosetStabChain",
    "MinimalGeneratingSet",
    "MinimalNonmonomialGroup",
    "MinimalNormalSubgroups",
    "MinimalPolynomial",
    "MinimalStabChain",
    "MinimalSupergroupsLattice",
    "MinimalSupergroupsTom",
    "MinimizedBombieriNorm",
    "Minimum",
    "MinimumList",
    "MinusCharacter",
    "ModuleByRestriction",
    "ModuleOfExtension",
    "ModuloPcgs",
    "MoebiusMu",
    "MoebiusTom",
    "MolienSeries",
    "MolienSeriesInfo",
    "MolienSeriesWithGivenDenominator",
    "Monoid",
    "MonoidByGenerators",
    "MonoidByMultiplicationTable",
    "MonoidOfRewritingSystem",
    "MonomialComparisonFunction",
    "MonomialExtGrlexLess",
    "MonomialExtrepComparisonFun",
    "MonomialGrevlexOrdering",
    "MonomialGrlexOrdering",
    "MonomialLexOrdering",
    "MorClassLoop",
    "MostFrequentGeneratorFpGroup",
    "MovedPoints",
    "MultiplicationTable",
    "MultiplicativeNeutralElement",
    "MultiplicativeZero",
    "MultiplicativeZeroOp",
    "MultRowVector",
    "MutableBasis",
    "MutableBasisOfClosureUnderAction",
    "MutableBasisOfIdealInNonassociativeAlgebra",
    "MutableBasisOfNonassociativeAlgebra",
    "MutableCopyMat",
    "MutableIdentityMat",
    "MutableNullMat",
    "Name",
    "NameFunction",
    "NameRNam",
    "NamesFilter",
    "NamesGVars",
    "NamesLocalVariablesFunction",
    "NamesOfFusionSources",
    "NamesSystemGVars",
    "NamesUserGVars",
    "NaturalCharacter",
    "NaturalHomomorphismByGenerators",
    "NaturalHomomorphismByIdeal",
    "NaturalHomomorphismByNormalSubgroup",
    "NaturalHomomorphismByNormalSubgroupNC",
    "NaturalHomomorphismBySubAlgebraModule",
    "NaturalHomomorphismBySubspace",
    "NearAdditiveGroup",
    "NearAdditiveGroupByGenerators",
    "NearAdditiveMagma",
    "NearAdditiveMagmaByGenerators",
    "NearAdditiveMagmaWithZero",
    "NearAdditiveMagmaWithZeroByGenerators",
    "NegativeRoots",
    "NegativeRootVectors",
    "NestingDepthA",
    "NestingDepthM",
    "NewInfoClass",
    "NewmanInfinityCriterion",
    "NextIterator",
    "NextPrimeInt",
    "NiceBasis",
    "NiceFreeLeftModule",
    "NiceFreeLeftModuleInfo",
    "NiceMonomorphism",
    "NiceMonomorphismAutomGroup",
    "NiceObject",
    "NiceVector",
    "NilpotencyClassOfGroup",
    "NilpotentQuotientOfFpLieAlgebra",
    "NK",
    "NonabelianExteriorSquare",
    "NonnegIntScalarProducts",
    "NonNilpotentElement",
    "Norm",
    "NormalBase",
    "NormalClosure",
    "NormalFormIntMat",
    "NormalIntersection",
    "NormalizedElementOfMagmaRingModuloRelations",
    "NormalizedWhitespace",
    "Normalizer",
    "NormalizerInGLnZ",
    "NormalizerInGLnZBravaisGroup",
    "NormalizersTom",
    "NormalizerTom",
    "NormalizeWhitespace",
    "NormalSeriesByPcgs",
    "NormalSubgroupClasses",
    "NormalSubgroupClassesInfo",
    "NormalSubgroups",
    "NormedRowVector",
    "NormedRowVectors",
    "NrArrangements",
    "NrBasisVectors",
    "NrCombinations",
    "NrConjugacyClasses",
    "NrConjugacyClassesGL",
    "NrConjugacyClassesGU",
    "NrConjugacyClassesPGL",
    "NrConjugacyClassesPGU",
    "NrConjugacyClassesPSL",
    "NrConjugacyClassesPSU",
    "NrConjugacyClassesSL",
    "NrConjugacyClassesSLIsogeneous",
    "NrConjugacyClassesSU",
    "NrConjugacyClassesSUIsogeneous",
    "NrDerangements",
    "NrInputsOfStraightLineProgram",
    "NrMovedPoints",
    "NrOrderedPartitions",
    "NrPartitions",
    "NrPartitionsSet",
    "NrPartitionTuples",
    "NrPermutationsList",
    "NrPolyhedralSubgroups",
    "NrPrimitiveGroups",
    "NrRestrictedPartitions",
    "NrSmallGroups",
    "NrSubsTom",
    "NrTransitiveGroups",
    "NrTuples",
    "NrUnorderedTuples",
    "NullAlgebra",
    "NullMat",
    "NullspaceIntMat",
    "NullspaceMat",
    "NullspaceMatDestructive",
    "NullspaceModQ",
    "Number",
    "NumberArgumentsFunction",
    "NumberFFVector",
    "NumberIrreducibleSolvableGroups",
    "NumberPerfectGroups",
    "NumberPerfectLibraryGroups",
    "NumberSmallGroups",
    "NumberSyllables",
    "NumeratorOfModuloPcgs",
    "NumeratorOfRationalFunction",
    "NumeratorRat",
    "ObjByExtRep",
    "OCOneCocycles",
    "OctaveAlgebra",
    "OldGeneratorsOfPresentation",
    "Omega",
    "ONanScottType",
    "One",
    "OneAttr",
    "OneCoboundaries",
    "OneCocycles",
    "OneFactorBound",
    "OneImmutable",
    "OneIrreducibleSolvableGroup",
    "OneMutable",
    "OneOfPcgs",
    "OneOp",
    "OneSameMutability",
    "OneSM",
    "OneSmallGroup",
    "OnIndeterminates",
    "OnLeftInverse",
    "OnLines",
    "OnPairs",
    "OnPoints",
    "OnRight",
    "OnSets",
    "OnSetsDisjointSets",
    "OnSetsSets",
    "OnSetsTuples",
    "OnSubspacesByCanonicalBasis",
    "OnTuples",
    "OnTuplesSets",
    "OnTuplesTuples",
    "OperationAlgebraHomomorphism",
    "Orbit",
    "OrbitFusions",
    "OrbitLength",
    "OrbitLengths",
    "OrbitLengthsDomain",
    "OrbitPerms",
    "OrbitPowerMaps",
    "Orbits",
    "OrbitsDomain",
    "OrbitsPerms",
    "OrbitStabChain",
    "OrbitStabilizer",
    "OrbitStabilizerAlgorithm",
    "Order",
    "OrderedPartitions",
    "OrderingByLessThanFunctionNC",
    "OrderingByLessThanOrEqualFunctionNC",
    "OrderingOfRewritingSystem",
    "OrderingOnGenerators",
    "OrderingsFamily",
    "OrderMod",
    "OrderOfRewritingSystem",
    "OrdersClassRepresentatives",
    "OrdersTom",
    "Ordinal",
    "OrdinaryCharacterTable",
    "OrthogonalComponents",
    "OrthogonalEmbeddings",
    "OrthogonalEmbeddingsSpecialDimension",
    "OutputLogTo",
    "OutputTextFile",
    "OutputTextNone",
    "OutputTextString",
    "OutputTextUser",
    "PadicCoefficients",
    "PadicExtensionNumberFamily",
    "PadicNumber",
    "PadicValuation",
    "Pager",
    "Parametrized",
    "Parent",
    "ParentPcgs",
    "PartialFactorization",
    "PartialOrderByOrderingFunction",
    "PartialOrderOfHasseDiagram",
    "Partitions",
    "PartitionsGreatestEQ",
    "PartitionsGreatestLE",
    "PartitionsSet",
    "PartitionTuples",
    "PcElementByExponents",
    "PcElementByExponentsNC",
    "PCentralLieAlgebra",
    "PCentralNormalSeriesByPcgsPGroup",
    "PCentralSeries",
    "PcGroupCode",
    "PcGroupCodeRec",
    "PcGroupFpGroup",
    "PcGroupWithPcgs",
    "Pcgs",
    "PcgsByPcSequence",
    "PcgsByPcSequenceNC",
    "PcgsCentralSeries",
    "PcgsChiefSeries",
    "PcgsElementaryAbelianSeries",
    "Pcgs_OrbitStabilizer",
    "PcgsPCentralSeriesPGroup",
    "PClassPGroup",
    "PCore",
    "PcSeries",
    "PerfectGroup",
    "PerfectIdentification",
    "PerfectResiduum",
    "Perform",
    "Permanent",
    "PermBounds",
    "PermCharInfo",
    "PermCharInfoRelative",
    "PermChars",
    "PermCharsTom",
    "PermComb",
    "PermLeftQuoTransformation",
    "PermList",
    "PermListList",
    "Permutation",
    "PermutationCharacter",
    "PermutationCycle",
    "PermutationCycleOp",
    "PermutationGModule",
    "PermutationMat",
    "PermutationsList",
    "PermutationTom",
    "Permuted",
    "PGL",
    "PGU",
    "Phi",
    "PolynomialByExtRep",
    "PolynomialByExtRepNC",
    "PolynomialCoefficientsOfPolynomial",
    "PolynomialDivisionAlgorithm",
    "PolynomialModP",
    "PolynomialReducedRemainder",
    "PolynomialReduction",
    "PolynomialRing",
    "PopOptions",
    "Position",
    "PositionBound",
    "PositionCanonical",
    "PositionFirstComponent",
    "PositionNonZero",
    "PositionNot",
    "PositionNthOccurrence",
    "PositionProperty",
    "Positions",
    "PositionSet",
    "PositionsOp",
    "PositionSorted",
    "PositionStream",
    "PositionSublist",
    "PositionWord",
    "PositiveRoots",
    "PositiveRootVectors",
    "PossibleClassFusions",
    "PossibleFusionsCharTableTom",
    "PossiblePowerMaps",
    "PowerMap",
    "PowerMapByComposition",
    "PowerMapOp",
    "PowerMapsAllowedBySymmetrizations",
    "PowerMod",
    "PowerModCoeffs",
    "PowerModInt",
    "PowerPartition",
    "PowerSubalgebraSeries",
    "PQuotient",
    "PrefrattiniSubgroup",
    "PreImage",
    "PreImageElm",
    "PreImages",
    "PreImagesElm",
    "PreimagesOfTransformation",
    "PreImagesRange",
    "PreImagesRepresentative",
    "PreImagesSet",
    "PresentationFpGroup",
    "PresentationNormalClosure",
    "PresentationNormalClosureRrs",
    "PresentationSubgroup",
    "PresentationSubgroupMtc",
    "PresentationSubgroupRrs",
    "PresentationViaCosetTable",
    "PrevPrimeInt",
    "PrimaryGeneratorWords",
    "PrimeBlocks",
    "PrimeBlocksOp",
    "PrimeField",
    "PrimePGroup",
    "PrimePowersInt",
    "PrimeResidues",
    "PrimitiveElement",
    "PrimitiveGroup",
    "PrimitiveGroupsIterator",
    "PrimitiveIdentification",
    "PrimitivePolynomial",
    "PrimitiveRoot",
    "PrimitiveRootMod",
    "Print",
    "PrintAmbiguity",
    "PrintArray",
    "PrintCharacterTable",
    "PrintFactorsInt",
    "PrintFormattingStatus",
    "PrintObj",
    "PrintTo",
    "ProbabilityShapes",
    "Process",
    "PROD_GF2MAT_GF2MAT_ADVANCED",
    "PROD_GF2MAT_GF2MAT_SIMPLE",
    "Product",
    "ProductCoeffs",
    "ProductOfStraightLinePrograms",
    "ProductSpace",
    "ProductX",
    "ProfileFunctions",
    "ProfileGlobalFunctions",
    "ProfileMethods",
    "ProfileOperations",
    "ProfileOperationsAndMethods",
    "ProjectedInducedPcgs",
    "ProjectedPcElement",
    "Projection",
    "ProjectionMap",
    "ProjectiveActionHomomorphismMatrixGroup",
    "ProjectiveActionOnFullSpace",
    "ProjectiveGeneralLinearGroup",
    "ProjectiveGeneralUnitaryGroup",
    "ProjectiveOrder",
    "ProjectiveSpecialLinearGroup",
    "ProjectiveSpecialUnitaryGroup",
    "ProjectiveSymplecticGroup",
    "PRump",
    "PseudoRandom",
    "PSL",
    "PSp",
    "PSP",
    "PSU",
    "PthPowerImage",
    "PthPowerImages",
    "PurePadicNumberFamily",
    "PushOptions",
    "Quadratic",
    "QuaternionAlgebra",
    "QuoInt",
    "Quotient",
    "QuotientFromSCTable",
    "QuotientMod",
    "QuotientPolynomialsExtRep",
    "QuotientRemainder",
    "QuotientSemigroupCongruence",
    "QuotientSemigroupHomomorphism",
    "QuotientSemigroupPreimage",
    "QuotRemLaurpols",
    "RadicalGroup",
    "RadicalOfAlgebra",
    "Random",
    "RandomBinaryRelationOnPoints",
    "RandomInvertibleMat",
    "RandomIsomorphismTest",
    "RandomList",
    "RandomMat",
    "RandomPrimitivePolynomial",
    "RandomSource",
    "RandomTransformation",
    "RandomUnimodularMat",
    "Range",
    "RankAction",
    "RankFilter",
    "RankMat",
    "RankOfTransformation",
    "RankPGroup",
    "Rat",
    "RationalClass",
    "RationalClasses",
    "RationalFunctionByExtRep",
    "RationalFunctionByExtRepNC",
    "RationalFunctionByExtRepWithCancellation",
    "RationalFunctionsFamily",
    "RationalizedMat",
    "RClassOfHClass",
    "Read",
    "ReadAll",
    "ReadAllLine",
    "ReadAsFunction",
    "ReadByte",
    "ReadLine",
    "ReadPackage",
    "ReadTest",
    "RealClasses",
    "RealizableBrauerCharacters",
    "RealPart",
    "RecNames",
    "ReduceCoeffs",
    "ReduceCoeffsMod",
    "ReducedAdditiveInverse",
    "ReducedCharacters",
    "ReducedClassFunctions",
    "ReducedComm",
    "ReducedConfluentRewritingSystem",
    "ReducedConjugate",
    "ReducedDifference",
    "ReducedForm",
    "ReducedGroebnerBasis",
    "ReducedInverse",
    "ReducedLeftQuotient",
    "ReducedOne",
    "ReducedPcElement",
    "ReducedPower",
    "ReducedProduct",
    "ReducedQuotient",
    "ReducedScalarProduct",
    "ReducedSum",
    "ReducedZero",
    "ReduceRules",
    "ReduceStabChain",
    "Ree",
    "ReeGroup",
    "ReesCongruenceOfSemigroupIdeal",
    "ReesMatrixSemigroup",
    "ReesMatrixSemigroupElement",
    "ReesZeroMatrixSemigroup",
    "ReesZeroMatrixSemigroupElement",
    "ReesZeroMatrixSemigroupElementIsZero",
    "RefinedPcGroup",
    "ReflectionMat",
    "ReflexiveClosureBinaryRelation",
    "RegularActionHomomorphism",
    "RegularModule",
    "RelationsOfFpSemigroup",
    "RelativeBasis",
    "RelativeBasisNC",
    "RelativeOrderOfPcElement",
    "RelativeOrders",
    "RelatorsOfFpGroup",
    "RemInt",
    "Remove",
    "RemoveCharacters",
    "RemoveFile",
    "RemoveOuterCoeffs",
    "RemoveRelator",
    "RemoveSet",
    "RemoveStabChain",
    "ReplacedString",
    "RepresentationsOfObject",
    "Representative",
    "RepresentativeAction",
    "RepresentativeLinearOperation",
    "RepresentativesContainedRightCosets",
    "RepresentativesFusions",
    "RepresentativeSmallest",
    "RepresentativesMinimalBlocks",
    "RepresentativesPerfectSubgroups",
    "RepresentativesPowerMaps",
    "RepresentativesSimpleSubgroups",
    "RepresentativeTom",
    "RepresentativeTomByGenerators",
    "RepresentativeTomByGeneratorsNC",
    "Reread",
    "RereadPackage",
    "Reset",
    "ResetOptionsStack",
    "RespectsAddition",
    "RespectsAdditiveInverses",
    "RespectsInverses",
    "RespectsMultiplication",
    "RespectsOne",
    "RespectsScalarMultiplication",
    "RespectsZero",
    "RestoreStateRandom",
    "RestrictedClassFunction",
    "RestrictedClassFunctions",
    "RestrictedMapping",
    "RestrictedPartitions",
    "RestrictedPerm",
    "RestrictedPermNC",
    "RestrictedTransformation",
    "RestrictOutputsOfSLP",
    "Resultant",
    "ResultOfStraightLineProgram",
    "ReturnFail",
    "ReturnFalse",
    "ReturnTrue",
    "Reversed",
    "RewindStream",
    "RewriteWord",
    "RightActingAlgebra",
    "RightActingRingOfIdeal",
    "RightAlgebraModule",
    "RightAlgebraModuleByGenerators",
    "RightCoset",
    "RightCosets",
    "RightCosetsNC",
    "RightDerivations",
    "RightIdeal",
    "RightIdealByGenerators",
    "RightIdealNC",
    "RightModuleByHomomorphismToMatAlg",
    "RightShiftRowVector",
    "RightTransversal",
    "Ring",
    "RingByGenerators",
    "RingWithOne",
    "RingWithOneByGenerators",
    "RNamObj",
    "RootInt",
    "RootMod",
    "RootOfDefiningPolynomial",
    "RootsMod",
    "RootsOfUPol",
    "RootsUnityMod",
    "RootSystem",
    "RoundCyc",
    "RowIndexOfReesMatrixSemigroupElement",
    "RowIndexOfReesZeroMatrixSemigroupElement",
    "Rules",
    "Runtime",
    "Runtimes",
    "S",
    "SameBlock",
    "SandwichMatrixOfReesMatrixSemigroup",
    "SandwichMatrixOfReesZeroMatrixSemigroup",
    "SaveWorkspace",
    "ScalarProduct",
    "SchurCover",
    "ScriptFromString",
    "SecHMSM",
    "SecondsDMYhms",
    "SeekPositionStream",
    "SemidirectProduct",
    "SemiEchelonBasis",
    "SemiEchelonBasisNC",
    "SemiEchelonMat",
    "SemiEchelonMatDestructive",
    "SemiEchelonMats",
    "SemiEchelonMatsDestructive",
    "SemiEchelonMatTransformation",
    "Semigroup",
    "SemigroupByGenerators",
    "SemigroupByMultiplicationTable",
    "SemigroupIdealByGenerators",
    "SemigroupOfRewritingSystem",
    "SemiSimpleType",
    "Set",
    "SetAssertionLevel",
    "SetCommutator",
    "SetConjugate",
    "SetCrystGroupDefaultAction",
    "SetEntrySCTable",
    "SetGasmanMessageStatus",
    "SetHelpViewer",
    "SetIndeterminateName",
    "SetInfoLevel",
    "SetName",
    "SetParent",
    "SetPower",
    "SetPrintFormattingStatus",
    "SetRecursionTrapInterval",
    "SetReducedMultiplication",
    "Setter",
    "SetX",
    "ShallowCopy",
    "ShiftedCoeffs",
    "ShiftedPadicNumber",
    "ShortestVectors",
    "ShortLexOrdering",
    "ShowArgument",
    "ShowArguments",
    "ShowDetails",
    "ShowImpliedFilters",
    "ShowMethods",
    "ShowOtherMethods",
    "ShrinkAllocationPlist",
    "ShrinkAllocationString",
    "ShrinkCoeffs",
    "ShrinkRowVector",
    "SiftedPcElement",
    "SiftedPermutation",
    "SiftedVector",
    "Sigma",
    "SignInt",
    "SignPartition",
    "SignPerm",
    "SimpleLieAlgebra",
    "SimpleSystem",
    "SimplifiedFpGroup",
    "SimplifyPresentation",
    "SimsNo",
    "SimultaneousEigenvalues",
    "SingleCollector",
    "SINT_CHAR",
    "Size",
    "SizeBlist",
    "SizeConsiderFunction",
    "SizeNumbersPerfectGroups",
    "SizeOfFieldOfDefinition",
    "SizesCentralizers",
    "SizesConjugacyClasses",
    "SizeScreen",
    "SizesPerfectGroups",
    "SizeStabChain",
    "SL",
    "SmallerDegreePermutationRepresentation",
    "SmallestGeneratorPerm",
    "SmallestMovedPoint",
    "SmallestRootInt",
    "SmallGeneratingSet",
    "SmallGroup",
    "SmallGroupsInformation",
    "SmithNormalFormIntegerMat",
    "SmithNormalFormIntegerMatTransforms",
    "SO",
    "Socle",
    "SocleTypePrimitiveGroup",
    "SolutionIntMat",
    "SolutionMat",
    "SolutionMatDestructive",
    "SolutionNullspaceIntMat",
    "Sort",
    "SortedCharacters",
    "SortedCharacterTable",
    "SortedList",
    "SortedSparseActionHomomorphism",
    "SortedTom",
    "Sortex",
    "SortingPerm",
    "SortParallel",
    "Source",
    "SourceOfIsoclinicTable",
    "Sp",
    "SP",
    "SparseActionHomomorphism",
    "SparseCartanMatrix",
    "SpecialLinearGroup",
    "SpecialOrthogonalGroup",
    "SpecialPcgs",
    "SpecialUnitaryGroup",
    "SplitCharacters",
    "SplitExtension",
    "SplitExtensions",
    "SplitString",
    "SplittingField",
    "Sqrt",
    "SquareRoots",
    "SSortedList",
    "StabChain",
    "StabChainBaseStrongGenerators",
    "StabChainImmutable",
    "StabChainMutable",
    "StabChainOp",
    "StabChainOptions",
    "Stabilizer",
    "StabilizerOfExternalSet",
    "StabilizerPcgs",
    "StandardAssociate",
    "StandardGeneratorsInfo",
    "StandardGeneratorsOfGroup",
    "StandardizeTable",
    "StarCyc",
    "State",
    "StateRandom",
    "Stirling1",
    "Stirling2",
    "StoredGroebnerBasis",
    "StoreFusion",
    "StraightLineProgElm",
    "StraightLineProgGens",
    "StraightLineProgram",
    "StraightLineProgramNC",
    "StraightLineProgramsTom",
    "StretchImportantSLPElement",
    "String",
    "StringDate",
    "StringOfResultOfStraightLineProgram",
    "StringPP",
    "StringTime",
    "StrongGeneratorsStabChain",
    "StronglyConnectedComponents",
    "StructuralCopy",
    "StructureConstantsTable",
    "StructureDescription",
    "SU",
    "Subalgebra",
    "SubAlgebraModule",
    "SubalgebraNC",
    "SubalgebraWithOne",
    "SubalgebraWithOneNC",
    "SubdirectProduct",
    "SubdirectProducts",
    "Subfield",
    "SubfieldNC",
    "Subfields",
    "Subgroup",
    "SubgroupByPcgs",
    "SubgroupByProperty",
    "SubgroupNC",
    "SubgroupOfWholeGroupByCosetTable",
    "SubgroupOfWholeGroupByQuotientSubgroup",
    "SubgroupProperty",
    "SubgroupShell",
    "SubgroupsSolvableGroup",
    "Submagma",
    "SubmagmaNC",
    "SubmagmaWithInverses",
    "SubmagmaWithInversesNC",
    "SubmagmaWithOne",
    "SubmagmaWithOneNC",
    "Submodule",
    "SubmoduleNC",
    "Submonoid",
    "SubmonoidNC",
    "SubnearAdditiveGroup",
    "SubnearAdditiveGroupNC",
    "SubnearAdditiveMagma",
    "SubnearAdditiveMagmaNC",
    "SubnearAdditiveMagmaWithZero",
    "SubnearAdditiveMagmaWithZeroNC",
    "SubnormalSeries",
    "Subring",
    "SubringNC",
    "SubringWithOne",
    "SubringWithOneNC",
    "Subsemigroup",
    "SubsemigroupNC",
    "Subspace",
    "SubspaceNC",
    "Subspaces",
    "SubstitutedWord",
    "SubsTom",
    "SubSyllables",
    "SubtractBlist",
    "SubtractSet",
    "Subword",
    "Successors",
    "Sum",
    "SumFactorizationFunctionPcgs",
    "SumIntersectionMat",
    "SumX",
    "SupersolvableResiduum",
    "SurjectiveActionHomomorphismAttr",
    "SuzukiGroup",
    "SylowComplement",
    "SylowSubgroup",
    "SylowSystem",
    "SymmetricClosureBinaryRelation",
    "SymmetricGroup",
    "SymmetricParentGroup",
    "SymmetricParts",
    "SymmetricPowerOfAlgebraModule",
    "Symmetrizations",
    "SymplecticComponents",
    "SymplecticGroup",
    "Sz",
    "TableAutomorphisms",
    "TableOfMarks",
    "TableOfMarksByLattice",
    "TableOfMarksCyclic",
    "TableOfMarksDihedral",
    "TableOfMarksFrobenius",
    "Tau",
    "TemporaryGlobalVarName",
    "Tensored",
    "TensorProductOfAlgebraModules",
    "TestConsistencyMaps",
    "Tester",
    "TestHomogeneous",
    "TestInducedFromNormalSubgroup",
    "TestJacobi",
    "TestMonomial",
    "TestMonomialQuick",
    "TestPackageAvailability",
    "TestPerm1",
    "TestPerm2",
    "TestPerm3",
    "TestPerm4",
    "TestPerm5",
    "TestQuasiPrimitive",
    "TestRelativelySM",
    "TestSubnormallyMonomial",
    "TietzeWordAbstractWord",
    "Trace",
    "TracedCosetFpGroup",
    "TraceImmediateMethods",
    "TraceMat",
    "TraceMethods",
    "TracePolynomial",
    "TransferDiagram",
    "Transformation",
    "TransformationData",
    "TransformationFamily",
    "TransformationNC",
    "TransformationRelation",
    "TransformationType",
    "TransformingPermutations",
    "TransformingPermutationsCharacterTables",
    "TransitiveClosureBinaryRelation",
    "TransitiveGroup",
    "TransitiveIdentification",
    "Transitivity",
    "TranslatorSubalgebra",
    "TransposedMat",
    "TransposedMatAttr",
    "TransposedMatDestructive",
    "TransposedMatImmutable",
    "TransposedMatMutable",
    "TransposedMatOp",
    "TransposedMatrixGroup",
    "TriangulizedIntegerMat",
    "TriangulizedIntegerMatTransform",
    "TriangulizedNullspaceMat",
    "TriangulizedNullspaceMatDestructive",
    "TriangulizeIntegerMat",
    "TriangulizeMat",
    "TrivialCharacter",
    "TrivialGroup",
    "TrivialIterator",
    "TrivialSubalgebra",
    "TrivialSubgroup",
    "TrivialSubmagmaWithOne",
    "TrivialSubmodule",
    "TrivialSubmonoid",
    "TrivialSubnearAdditiveMagmaWithZero",
    "TrivialSubspace",
    "TryCosetTableInWholeGroup",
    "TryGcdCancelExtRepPolynomials",
    "Tuples",
    "TwoClosure",
    "TwoCoboundaries",
    "TwoCocycles",
    "TwoCohomology",
    "TwoSidedIdeal",
    "TwoSidedIdealByGenerators",
    "TwoSidedIdealNC",
    "TwoSquares",
    "TypeObj",
    "TypeOfDefaultGeneralMapping",
    "TzEliminate",
    "TzFindCyclicJoins",
    "TzGo",
    "TzGoGo",
    "TzImagesOldGens",
    "TzInitGeneratorImages",
    "TzNewGenerator",
    "TzOptions",
    "TzPreImagesNewGens",
    "TzPrint",
    "TzPrintGeneratorImages",
    "TzPrintGenerators",
    "TzPrintLengths",
    "TzPrintOptions",
    "TzPrintPairs",
    "TzPrintPresentation",
    "TzPrintRelators",
    "TzPrintStatus",
    "TzSearch",
    "TzSearchEqual",
    "TzSort",
    "TzSubstitute",
    "TzSubstituteCyclicJoins",
    "UglyVector",
    "Unbind",
    "UnbindGlobal",
    "UnderlyingCharacteristic",
    "UnderlyingCharacterTable",
    "UnderlyingElement",
    "UnderlyingElementOfReesMatrixSemigroupElement",
    "UnderlyingElementOfReesZeroMatrixSemigroupElement",
    "UnderlyingExternalSet",
    "UnderlyingFamily",
    "UnderlyingGeneralMapping",
    "UnderlyingGroup",
    "UnderlyingLeftModule",
    "UnderlyingLieAlgebra",
    "UnderlyingMagma",
    "UnderlyingRelation",
    "UnInstallCharReadHookFunc",
    "Union",
    "Union2",
    "UnionBlist",
    "Unique",
    "UniteBlist",
    "UniteBlistList",
    "UniteSet",
    "Units",
    "UnivariatenessTestRationalFunction",
    "UnivariatePolynomial",
    "UnivariatePolynomialByCoefficients",
    "UnivariatePolynomialRing",
    "UnivariateRationalFunctionByCoefficients",
    "UniversalEnvelopingAlgebra",
    "UNIXSelect",
    "Unknown",
    "UnloadSmallGroupsData",
    "UnorderedTuples",
    "UnprofileFunctions",
    "UnprofileMethods",
    "UntraceMethods",
    "UpdateMap",
    "UpEnv",
    "UpperCentralSeriesOfGroup",
    "UpperSubdiagonal",
    "UseBasis",
    "UseFactorRelation",
    "UseIsomorphismRelation",
    "UseSubsetRelation",
    "Valuation",
    "Value",
    "ValueCochain",
    "ValueGlobal",
    "ValueMolienSeries",
    "ValueOption",
    "ValuePol",
    "ValuesOfClassFunction",
    "VectorSpace",
    "VectorSpaceByPcgsOfElementaryAbelianGroup",
    "View",
    "ViewObj",
    "VirtualCharacter",
    "WeekDay",
    "WeightLexOrdering",
    "WeightOfGenerators",
    "WeightsTom",
    "WeightVecFFE",
    "WeylGroup",
    "WeylOrbitIterator",
    "Where",
    "WordAlp",
    "WreathProduct",
    "WreathProductImprimitiveAction",
    "WreathProductOrdering",
    "WreathProductProductAction",
    "WriteAll",
    "WriteByte",
    "WriteLine",
    "Z",
    "ZClassRepsQClass",
    "Zero",
    "ZeroAttr",
    "ZeroCoefficient",
    "ZeroCoefficientRatFun",
    "ZeroImmutable",
    "ZeroMapping",
    "ZeroMutable",
    "ZeroOp",
    "ZeroSameMutability",
    "ZeroSM",
    "ZippedProduct",
    "ZippedSum",
    "ZmodnZ",
    "ZmodnZObj",
    "ZmodpZ",
    "ZmodpZNC",
    "ZumbroichBase",
    "Zuppos",
]


text:
<?php

class Pronamic_Google_Maps_Post {
	/**
	 * Meta key for the Google Maps active meta data
	 *
	 * @var string
	 */
	const META_KEY_ACTIVE = '_pronamic_google_maps_active';

	/**
	 * Meta key for the Google Maps latitude meta data
	 *
	 * @var string
	 */
	const META_KEY_LATITUDE = '_pronamic_google_maps_latitude';

	/**
	 * Meta key for the Google Map longitude meta data
	 *
	 * @var string
	 */
	const META_KEY_LONGITUDE = '_pronamic_google_maps_longitude';

	/**
	 * Meta key for the Google Map address meta data
	 *
	 * @var string
	 */
	const META_KEY_ADDRESS = '_pronamic_google_maps_address';

	/**
	 * Meta key for the Google Maps title meta data
	 *
	 * @var string
	 */
	const META_KEY_TITLE = '_pronamic_google_maps_title';

	/**
	 * Meta key for the Google Maps info meta data
	 *
	 * @var string
	 * @deprecated
	 */
	const META_KEY_DESCRIPTION = '_pronamic_google_maps_description';

	/**
	 * Meta key for the Google Maps map type data
	 *
	 * @var string
	 */
	const META_KEY_MAP_TYPE = '_pronamic_google_maps_map_type';

	/**
	 * Meta key for the Google Maps map zoom level
	 *
	 * @var string
	 */
	const META_KEY_ZOOM = '_pronamic_google_maps_zoom';

	/**
	 * Meta key for the Google Maps geocode status
	 *
	 * @var string
	 */
	const META_KEY_GEOCODE_STATUS = '_pronamic_google_maps_geocode_status';
}

redpajama_set_name: RedPajamaGithub


text:
#ifndef SETUP_H
#define SETUP_H

void setup(void);

#endif /* SETUP_H */


text:
    @foreach ($profiles as $profile)

                    avatar) }}" alt="{{ $profile->name }} Username" class="img-fluid rounded-circle">

{{ $profile->name }}

    @endforeach


text:
'use strict';

var MongoClient = require('mongodb').MongoClient;

MongoClient.connect(
  'mongodb://mongo:27017/accounting',
  function (err, connection) {
    var collection = connection.collection('customers');

    collection.ensureIndex('v', function(err, indexName) {
      connection.close();
    });

  }
);


text:
package com.azure.resourcemanager.elastic.generated;

import com.azure.core.util.BinaryData;
import com.azure.resourcemanager.elastic.models.ElasticCloudDeployment;
import org.junit.jupiter.api.Test;

public final class ElasticCloudDeploymentTests {
    @Test
    public void testDeserialize() {
        ElasticCloudDeployment model =
            BinaryData
                .fromString(
                    "{\"name\":\"bmbexppbhtqqro\",\"deploymentId\":\"p\",\"azureSubscriptionId\":\"s\",\"elasticsearchRegion\":\"gbquxigj\",\"elasticsearchServiceUrl\":\"gzjaoyfhrtxilne\",\"kibanaServiceUrl\":\"ujysvle\",\"kibanaSsoUrl\":\"vfqawrlyxwjkcpr\"}")
                .toObject(ElasticCloudDeployment.class);
    }

    @Test
    public void testSerialize() {
        ElasticCloudDeployment model = new ElasticCloudDeployment();
        model = BinaryData.fromObject(model).toObject(ElasticCloudDeployment.class);
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
              android:gravity="center"
>
    <TextView
            android:layout_gravity="center"
            android:gravity="center"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@string/selected_hero_index"/>
    <ListView
            android:layout_width="fill_parent"
            android:layout_height="0dp"
            android:layout_weight="1.5"
            android:id="@+id/selected_hero_index"
    />

    <LinearLayout
            android:orientation="horizontal"
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

        <Button
                android:id="@+id/new_index"
                android:text="@string/create_index"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                style="@android:style/Widget.Button.Inset"/>

        <Button
                style="@android:style/Widget.Button.Inset"
                android:text="恢复存档"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:id="@+id/recove_save"
                android:visibility="visible"
                android:layout_weight="1"/>
    </LinearLayout>

</LinearLayout>


text:
namespace chrono
{
namespace geometry
{

#define EPS_SHPEREDEGENERATE 1e-20

#define CH_GEOCLASS_SPHERE   2

///
/// A sphere.
/// Geometric object for collisions and such.
///

class ChApi ChSphere : public ChGeometry
{
							// Chrono simulation of RTTI, needed for serialization
	CH_RTTI(ChSphere,ChGeometry);

public:

		//
		// CONSTRUCTORS
		//

	ChSphere()
				{
					center= VNULL;
					rad = 0;
				};

	ChSphere(Vector& mc, double mrad)
				{
					center = mc;
					rad = mrad;
				}

	ChSphere(const ChSphere & source)
				{
					Copy(&source);
				}

	void Copy (const ChSphere* source)
				{
					center = source->center;
					rad = source->rad;
				};

	ChGeometry* Duplicate ()
				{
					ChGeometry* mgeo = new ChSphere();
					mgeo->Copy(this); return mgeo;
				};

		//
		// OVERRIDE BASE CLASS FUNCTIONS
		//

	virtual int GetClassType () {return CH_GEOCLASS_SPHERE;};

	virtual void GetBoundingBox(double& xmin, double& xmax,
					    double& ymin, double& ymax,
						double& zmin, double& zmax,
						ChMatrix33<>* Rot = NULL)
				{
					Vector trsfCenter = center;
					if (Rot)
					{
						trsfCenter = Rot->MatrT_x_Vect(center);
					}
					xmin=trsfCenter.x-rad;
					xmax=trsfCenter.x+rad;
					ymin=trsfCenter.y-rad;
					ymax=trsfCenter.y+rad;
					zmin=trsfCenter.z-rad;
					zmax=trsfCenter.z+rad;
				}

	virtual Vector Baricenter() {return center;};

	virtual void CovarianceMatrix(ChMatrix33<>& C)
				{
					C.Reset();
					C(0,0)= center.x*center.x;
					C(1,1)= center.y*center.y;
					C(2,2)= center.z*center.z;
				};

				/// This is a solid
	virtual int GetManifoldDimension() {return 3;}

		//
		// DATA
		//

	Vector center;

	double rad;

		//
		// STREAMING
		//

	void StreamOUT(ChStreamOutBinary& mstream);

	void StreamIN(ChStreamInBinary& mstream);

};

} // END_OF_NAMESPACE____
} // END_OF_NAMESPACE____

#endif


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
Mém. Soc. natn. Sci. nat. math. Cherbourg 3: (1857)

#### Original name
Gyrothecium polysporum Nyl.

### Remarks
null


text:
from __future__ import print_function

from setuptools import setup
import sys

import os
# Don't use hardlinks while testing from vagrant guest fs
# http://stackoverflow.com/questions/7719380/python-setup-py-sdist-error-operation-not-permitted
if os.environ.get('USER','') == 'vagrant':
    del os.link

try:
	with open("README.rst", "rb") as f:
		readme = f.read().decode("utf-8")
except:
	readme = ""
	print("Warning, unable to load README.rst into long_description.")

setup(
	name="hkdf",
	version="0.0.3",
	description="HMAC-based Extract-and-Expand Key Derivation Function (HKDF)",
	author="Christopher H. Casebeer",
	author_email="",
	url="https://github.com/casebeer/python-hkdf",

	py_modules=["hkdf"],

	tests_require=["nose"],
	test_suite="nose.collector",

	long_description=readme,
	classifiers=[
		"License :: OSI Approved :: BSD License",
		"Intended Audience :: Developers",
		"Programming Language :: Python :: 2.6",
		"Programming Language :: Python :: 2.7",
		"Programming Language :: Python :: 3.3",
		"Programming Language :: Python :: 3.4",
	]
)


text:
SCLAlertView
===========

Animated Alert View written in Swift, which can be used as a `UIAlertView` or `UIAlertController` replacement. Since `UIAlertView` is deprecated and `UIAlertController` only works on iOS 8.x or above, if you have a Swift project where you want to support iOS 7.x too, SCLAlertView is an ideal substitution.

![BackgroundImage](https://raw.githubusercontent.com/vikmeup/SCPopUpView/master/successScreenshot.png)_
![BackgroundImage](https://raw.githubusercontent.com/vikmeup/SCPopUpView/master/editScreenshot.png)

Easy to use
----

### Get Started

```swift
// Get started
SCLAlertView().showInfo("Important info", subTitle: "You are great")
```

### Updating the alert view

```swift
let alertViewResponder: SCLAlertViewResponder = SCLAlertView().showSuccess("Hello World", subTitle: "This is a more descriptive text.")

// Upon displaying, change/close view
alertViewResponder.setTitle("New Title") // Rename title
alertViewResponder.setSubTitle("New description") // Rename subtitle
alertViewResponder.close() // Close view
```

### Alternative alert types

```
SCLAlertView().showError("Hello Error", subTitle: "This is a more descriptive error text.") // Error
SCLAlertView().showNotice("Hello Notice", subTitle: "This is a more descriptive notice text.") // Notice
SCLAlertView().showWarning("Hello Warning", subTitle: "This is a more descriptive warning text.") // Warning
SCLAlertView().showInfo("Hello Info", subTitle: "This is a more descriptive info text.") // Info
SCLAlertView().showEdit("Hello Edit", subTitle: "This is a more descriptive info text.") // Edit
```

### Raw call to showTitle()

```swift
SCLAlertView().showTitle(
    "Congratulations", // Title of view
    subTitle: "Operation successfully completed.", // String of view
    duration: 2.0, // Duration to show before closing automatically, default: 0.0
    completeText: "Done", // Optional button value, default: ""
    style: .Success, // Styles - see below.
    colorStyle: 0xA429FF,
    colorTextButton: 0xFFFFFF
)
```

### Controls

#### Add buttons

```swift
let alertView = SCLAlertView()
alertView.addButton("First Button", target:self, selector:Selector("firstButton"))
alertView.addButton("Second Button") {
    println("Second button tapped")
}
alertView.showSuccess("Button View", subTitle: "This alert view has buttons")
```

#### Hide default close button

```swift
let alertView = SCLAlertView()
alertView.showCloseButton = false
alertView.showSuccess("No button", subTitle: "You will have hard times trying to close me")
```

#### Add Text fields

```swift
// Add a text field
let alert = SCLAlertView()
let txt = alert.addTextField(title:"Enter your name")
alert.addButton("Show Name") {
    println("Text value: \(txt.text)")
}
alert.showEdit("Edit View", subTitle: "This alert view shows a text box")
```

### Alert View Styles

```swift
enum SCLAlertViewStyle: Int {
    case Success, Error, Notice, Warning, Info, Edit, Wait
}
```

Installation
---

SCLAlertView is available through [CocoaPods](http://cocoapods.org).

To install add the following line to your Podfile:

    pod 'SCLAlertView'

Collaboration
---

I tried to build an easy to use API, while beeing flexible enough for multiple variations, but I'm sure there are ways of improving and adding more features, so feel free to collaborate with ideas, issues and/or pull requests.

Incoming improvements
---

- More animations
- Performance tests

Has been developed initially for the [Scroll Feed](https://itunes.apple.com/us/app/scroll-feed/id842422195?ls=1&mt=8) app

- Design [@SherzodMx](https://twitter.com/SherzodMx) Sherzod Max
- Development [@vikmeup](https://twitter.com/vikmeup) Viktor Radchenko
- Improvements by [@bih](http://github.com/bih) Bilawal Hameed, [@rizjoj](http://github.com/rizjoj) Riz Joj


text:
package com.netthreads.trader.convertor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.convert.converter.Converter;

import com.netthreads.trader.domain.SolutionType;
import com.netthreads.trader.service.SolutionTypeService;

/**
 * Used by controllers to convert an ID into a object.
 *
 */
public class SolutionTypeConvertor implements Converter<String, SolutionType>
{

	@Autowired
	private SolutionTypeService service;

	@Override
	public SolutionType convert(String source)
	{
		return service.findById(Integer.valueOf(source));
	}

}


text:
(function() {
  'use strict';

  var PIXI = require('pixi.js');

  function Spring() {
		var texture = PIXI.Texture.fromFrame('Spring.png');
    PIXI.Sprite.call(this, texture);

    this.update = function() {

    };
 }

  Spring.prototype = Object.create(PIXI.Sprite.prototype);
  Spring.prototype.constructor = Spring;
  module.exports = Spring;

})();


text:
SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";

CREATE DATABASE IF NOT EXISTS capturedFrames;

USE capturedFrames;

CREATE TABLE IF NOT EXISTS `muc` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `address` char(11) NOT NULL DEFAULT '',
  `value` text NOT NULL,
  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `key` char(32) NOT NULL,
  PRIMARY KEY (`ID`),
  UNIQUE KEY `address` (`address`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

CREATE TABLE IF NOT EXISTS `sniffedFrames` (
  `ID` int(11) NOT NULL AUTO_INCREMENT,
  `value` text NOT NULL,
  `timestamp` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;


text:
To configure SaveModel or checkpointing beyond the basic saving and loading
steps [documentation TBD], registration is required.

Currently, only TensorFlow-internal
registrations are allowed, and must be added to the allowlist.

* `tensorflow.python.saved_model.registration.register_tf_serializable`
  * Allowlist: tf_serializable_allowlist.txt
*  `tensorflow.python.saved_model.registration.register_tf_checkpoint_saver`
  * Allowlist: tf_checkpoint_saver_allowlist.txt

[TOC]

## SavedModel serializable registration

Custom objects must be registered in order to get the correct deserialization
method when loading. The registered name of the class is saved to the proto.

Keras already has a similar mechanism for registering serializables:
[`tf.keras.utils.register_keras_serializable(package, name)`](https://www.tensorflow.org/api_docs/python/tf/keras/utils/register_keras_serializable).
This has been imported to core TensorFlow:

```python
registration.register_serializable(package, name)
registration.register_tf_serializable(name)  # If TensorFlow-internal.
```

*   package: The package that this class belongs to.
*   name: The name of this class. The registered name that is saved in the proto
    is "{package}.{name}" (for TensorFlow internal registration, the package
    name is `tf`)

## Checkpoint saver registration

If `Trackables` share state or require complicated coordination between multiple
`Trackables` (e.g. `DTensor`), then users may register a save and restore
functions for these objects.

```
tf.saved_model.register_checkpoint_saver(
    predicate, save_fn=None, restore_fn=None):
```

*   `predicate`: A function that returns `True` if a `Trackable` object should
    be saved using the registered `save_fn` or `restore_fn`.
*   `save_fn`: A python function or `tf.function` or `None`. If `None`, run the
    default saving process which calls `Trackable._serialize_to_tensors`.
*   `restore_fn`: A `tf.function` or `None`. If `None`, run the default
    restoring process which calls `Trackable._restore_from_tensors`.

**`save_fn` details**

```
@tf.function  # optional decorator
def save_fn(trackables, file_prefix): -> List[shard filenames]
```

*   `trackables`: A dictionary of `{object_prefix: Trackable}`. The
    object_prefix can be used as the object names, and uniquely identify each
    `Trackable`. `trackables` is the filtered set of trackables that pass the
    predicate.
*   `file_prefix`: A string or string tensor of the checkpoint prefix.
*   `shard filenames`: A list of filenames written using `io_ops.save_v2`, which
    will be merged into the checkpoint data files. These should be prefixed by
    `file_prefix`.

This function can be a python function, in which case shard filenames can be an
empty list (if the values are written without the `SaveV2` op).

If this function is a `tf.function`, then the shards must be written using the
SaveV2 op. This guarantees the checkpoint format is compatible with existing
checkpoint readers and managers.

**`restore_fn` details**

```
@tf.function  # required decorator
def restore_fn(trackables, file_prefix): -> None
```

A `tf.function` with the spec:

*   `trackables`: A dictionary of `{object_prefix: Trackable}`. The
    `object_prefix` can be used as the object name, and uniquely identifies each
    Trackable. The Trackable objects are the filtered results of the registered
    predicate.
*   `file_prefix`: A string or string tensor of the checkpoint prefix.

**Why are restore functions required to be a `tf.function`?** The short answer
is, the SavedModel format must maintain the invariant that SavedModel packages
can be used for inference on any platform and language. SavedModel inference
needs to be able to restore checkpointed values, so the restore function must be
directly encoded into the SavedModel in the Graph. We also have security
measures over FunctionDef and GraphDef, so users can check that the SavedModel
will not run arbitrary code (a feature of `saved_model_cli`).

## Example

Below shows a `Stack` module that contains multiple `Parts` (a subclass of
`tf.Variable`). When a `Stack` is saved to a checkpoint, the `Parts` are stacked
together and a single entry in the checkpoint is created. The checkpoint value
is restored to all of the `Parts` in the `Stack`.

```
@registration.register_serializable()
class Part(resource_variable_ops.ResourceVariable):

  def __init__(self, value):
    self._init_from_args(value)

  @classmethod
  def _deserialize_from_proto(cls, **kwargs):
    return cls([0, 0])

@registration.register_serializable()
class Stack(tracking.AutoTrackable):

  def __init__(self, parts=None):
    self.parts = parts

  @def_function.function(input_signature=[])
  def value(self):
    return array_ops.stack(self.parts)

def get_tensor_slices(trackables):
  tensor_names = []
  shapes_and_slices = []
  tensors = []
  restored_trackables = []
  for obj_prefix, obj in trackables.items():
    if isinstance(obj, Part):
      continue  # only save stacks
    tensor_names.append(obj_prefix + "/value")
    shapes_and_slices.append("")
    x = obj.value()
    with ops.device("/device:CPU:0"):
      tensors.append(array_ops.identity(x))
    restored_trackables.append(obj)

  return tensor_names, shapes_and_slices, tensors, restored_trackables

def save_stacks_and_parts(trackables, file_prefix):
  """Save stack and part objects to a checkpoint shard."""
  tensor_names, shapes_and_slices, tensors, _ = get_tensor_slices(trackables)
  io_ops.save_v2(file_prefix, tensor_names, shapes_and_slices, tensors)
  return file_prefix

def restore_stacks_and_parts(trackables, merged_prefix):
  tensor_names, shapes_and_slices, tensors, restored_trackables = (
      get_tensor_slices(trackables))
  dtypes = [t.dtype for t in tensors]
  restored_tensors = io_ops.restore_v2(merged_prefix, tensor_names,
                                       shapes_and_slices, dtypes)
  for trackable, restored_tensor in zip(restored_trackables, restored_tensors):
    expected_shape = trackable.value().get_shape()
    restored_tensor = array_ops.reshape(restored_tensor, expected_shape)
    parts = array_ops.unstack(restored_tensor)
    for part, restored_part in zip(trackable.parts, parts):
      part.assign(restored_part)

registration.register_checkpoint_saver(
    name="stacks",
    predicate=lambda x: isinstance(x, (Stack, Part)),
    save_fn=save_stacks_and_parts,
    restore_fn=restore_stacks_and_parts)
```


text:
module Faraday
  module Webmachine
    VERSION = "0.0.1"
  end
end


text:
import { Component } from 'react'

import WithGmap from './WithGmapHOC'

import Event from 'Types/Event'
import Coordinates from 'Types/Coordinates'

type Props = {
    zoom: number,
    center: Coordinates,
    domListeners?: Array<Event>,
    children?: any
};

const Map = WithGmap(class extends Component {
    props: Props;
});

export default Map;


text:
FROM eclipse-temurin:11-jre-focal
LABEL maintainer="contact@graviteesource.com"

ARG GRAVITEEIO_AM_VERSION=0
ARG GRAVITEEIO_DOWNLOAD_URL=https://download.gravitee.io/graviteeio-ee/am/distributions
ENV GRAVITEEIO_HOME /opt/graviteeio-am-gateway

RUN apt-get update \
    && apt-get --yes upgrade \
    && apt-get --yes install wget unzip htop \
	&& wget ${GRAVITEEIO_DOWNLOAD_URL}/graviteeio-ee-am-full-${GRAVITEEIO_AM_VERSION}.zip --no-check-certificate -P /tmp \
    && unzip /tmp/graviteeio-ee-am-full-${GRAVITEEIO_AM_VERSION}.zip -d /tmp/ \
    && mv /tmp/graviteeio-ee-am-full-${GRAVITEEIO_AM_VERSION}/graviteeio-am-gateway* ${GRAVITEEIO_HOME} \
    && rm -rf /tmp/* \
    && rm -rf /var/lib/apt/lists/* \
	&& chgrp -R 0 ${GRAVITEEIO_HOME} \
    && chmod -R g=u ${GRAVITEEIO_HOME}

WORKDIR ${GRAVITEEIO_HOME}

EXPOSE 8092
CMD ["./bin/gravitee"]


text:
#pragma once

#include <functional>
#include <thread>
#include <chrono>

namespace darwin {
	typedef unsigned long timer_t;

	class timer;
}
class darwin::timer final {
	static std::chrono::time_point <std::chrono::high_resolution_clock> m_timer;
public:
	enum class time_unit {
		nano_sec, micro_sec, milli_sec, second, minute
	};

	static void reset()
	{
		m_timer = std::chrono::high_resolution_clock::now();
	}

	static timer_t time(time_unit unit = time_unit::milli_sec)
	{
		switch (unit) {
		case time_unit::nano_sec:
			return std::chrono::duration_cast<std::chrono::nanoseconds>(
			           std::chrono::high_resolution_clock::now() - m_timer).count();
		case time_unit::micro_sec:
			return std::chrono::duration_cast<std::chrono::microseconds>(
			           std::chrono::high_resolution_clock::now() - m_timer).count();
		case time_unit::milli_sec:
			return std::chrono::duration_cast<std::chrono::milliseconds>(
			           std::chrono::high_resolution_clock::now() - m_timer).count();
		case time_unit::second:
			return std::chrono::duration_cast<std::chrono::seconds>(
			           std::chrono::high_resolution_clock::now() - m_timer).count();
		case time_unit::minute:
			return std::chrono::duration_cast<std::chrono::minutes>(
			           std::chrono::high_resolution_clock::now() - m_timer).count();
		}
		return 0;
	}

	static void delay(timer_t time, time_unit unit = time_unit::milli_sec)
	{
		switch (unit) {
		case time_unit::nano_sec:
			std::this_thread::sleep_for(std::chrono::nanoseconds(time));
			break;
		case time_unit::micro_sec:
			std::this_thread::sleep_for(std::chrono::microseconds(time));
			break;
		case time_unit::milli_sec:
			std::this_thread::sleep_for(std::chrono::milliseconds(time));
			break;
		case time_unit::second:
			std::this_thread::sleep_for(std::chrono::seconds(time));
			break;
		case time_unit::minute:
			std::this_thread::sleep_for(std::chrono::minutes(time));
			break;
		}
	}

	static timer_t measure(const std::function<void()> &func, time_unit unit = time_unit::milli_sec)
	{
		timer_t begin(0), end(0);
		begin = time(unit);
		func();
		end = time(unit);
		return end - begin;
	}
};

std::chrono::time_point <std::chrono::high_resolution_clock>
darwin::timer::m_timer(std::chrono::high_resolution_clock::now());


text:
<?php namespace App\Http\Livewire;

use Livewire\Component;

class JsonFormatter extends Component
{
    public string $json = '{"hello":"world"}';

    public function formattedJson()
    {
        try {
            return json_encode(json_decode($this->json, flags: \JSON_THROW_ON_ERROR), \JSON_PRETTY_PRINT | \JSON_UNESCAPED_UNICODE);
        } catch (\Throwable) {
            return 'Specified json is invalid. Please correct it.';
        }
    }
}


text:
package algorithms;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class HeapSortTest {
    @Test
    public void testSort() {
        Integer[] array = new Integer[]{10, 1, 4, 2, 6, 7, 3, 5, 8, 9};
        HeapSort.sort(array);
        assertEquals("1 2 3 4 5 6 7 8 9 10", join(array, " "));
    }

    private <T> String join(T[] array, String separator) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < array.length; i++) {
            sb.append(array[i]);
            if (i != array.length - 1) {
                sb.append(separator);
            }
        }
        return sb.toString();
    }
}


text:
class CreateSweeps < ActiveRecord::Migration
  def change
    create_table :sweeps do |t|
      t.string :name
      t.belongs_to :user
      t.belongs_to :workflow
      t.integer :workflow_version
      t.timestamps
    end
  end
end