typeNesting.forEach(element -> {
            if (element instanceof PackageElement) {
                typeName.append(((PackageElement) element).getQualifiedName().toString().replace(".", "/")).append("/");
            } else {
                typeName.append(element.getSimpleName().toString());
                if (element != typeNesting.get(typeNesting.size() - 1)) {

Diagnostics from elements:
  for PSI element of type KtObjectDeclaration at (7,14-48)
    ABSTRACT_MEMBER_NOT_IMPLEMENTED      text ranges: [(110,116)]
      PSI: KtObjectDeclaration at (7,14-48)
  for PSI element of type KtConstantExpression at (4,9-10)
    ARGUMENT_TYPE_MISMATCH      text ranges: [(88,89)]
      PSI: KtConstantExpression at (4,9-10)
  for PSI element of type KtConstantExpression at (10,38-39)
    RETURN_TYPE_MISMATCH      text ranges: [(230,231)]

                return element.getFiles();
            }
        };
    }

    /**
     * Returns a transform that replace the content of the before element with the content of the after element.
     * Both elements must have the same location.
     */
    protected static Transform modify(final SourceElement beforeElement, final SourceElement afterElement) {

Diagnostics from elements:
  for PSI element of type KtObjectDeclaration at (7,14-48)
    ABSTRACT_MEMBER_NOT_IMPLEMENTED      text ranges: [(110,116)]
      PSI: KtObjectDeclaration at (7,14-48)
  for PSI element of type KtConstantExpression at (10,38-39)
    CONSTANT_EXPECTED_TYPE_MISMATCH      text ranges: [(230,231)]
      PSI: KtConstantExpression at (10,38-39)
  for PSI element of type KtConstantExpression at (4,9-10)

            checkForComodification();
            backingList.set(previousIndex, new Element<>(t));
        }

        @Override
        public void add(T t) {
            checkForComodification();
            Element<T> element = new Element<>(t);
            backingList.add(nextIndex, element);
            nextIndex++;
            previous = element.getValues().get(0);
            previousIndex = nextIndex;

    Class<T> getElementType();

    /**
     * Adds an element to the property value.
     *
     * <p>
     * When invoked on a property with no value, this method first sets the value
     * of the property to its current convention value, if set, or an empty collection.
     * </p>
     *
     * @param element The element
     */
    @Incubating
    void append(T element);

    /**
     * Adds an element to the property value.

    fun push(element: T) {
        lock.withLock {
            q.addFirst(element)
            if (q.size == 1) {
                notEmpty.signal()
            }
        }
    }

    /**
     * Returns the next group of elements after removing them from the queue.
     *
     * The group contains the most recently pushed element plus all

func BenchmarkAdd(b *testing.B) {
	x := new(Element).One()
	y := new(Element).Add(x, x)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		x.Add(x, y)
	}
}

func BenchmarkMultiply(b *testing.B) {
	x := new(Element).One()
	y := new(Element).Add(x, x)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		x.Multiply(x, y)
	}
}

func BenchmarkSquare(b *testing.B) {
	x := new(Element).Add(feOne, feOne)
	b.ResetTimer()

}


class CodeAnalyzerImpl(
    private val analysisStatementFilter: AnalysisStatementFilter,
    private val statementResolver: StatementResolver
) : CodeAnalyzer {
    override fun analyzeStatementsInProgramOrder(
        context: AnalysisContext,
        elements: List<DataStatement>
    ) {
        for (element in elements) {

  boolean isPartialView() {
    return false;
  }

  @Override
  public int count(@CheckForNull Object element) {
    @Nullable ImmutableEntry<?>[] hashTable = this.hashTable;
    if (element == null || hashTable.length == 0) {
      return 0;
    }
    int hash = Hashing.smearedHash(element);
    int mask = hashTable.length - 1;
    for (ImmutableEntry<?> entry = hashTable[hash & mask];
        entry != null;