for (int i = elements.length - 1; i >= 0; i--) {
                      list.add(elements[i]);
                    }
                    return Lists.reverse(list);
                  }
                })
            .named("Lists.reverse[ArrayList]")
            .withFeatures(
                CollectionSize.ANY,
                CollectionFeature.ALLOWS_NULL_VALUES,
                ListFeature.GENERAL_PURPOSE)

            }
        }

        boolean reverse = false;

        if (jdk.startsWith("!")) {
            reverse = true;
            jdk = jdk.substring(1);
        }

        if (getJdkVersion().startsWith(jdk)) {
            return !reverse;
        } else {
            return reverse;
        }
    }

	for stdin.Scan() {
		p := stdin.Text()
		if strings.Contains(p, ":") {
			// Reverse translate file:line to pc.
			// This was an extension in the old C version of 'go tool addr2line'
			// and is probably not used by anyone, but recognize the syntax.
			// We don't have an implementation.
			fmt.Fprintf(stdout, "!reverse translation not implemented\n")
			continue
		}

    assertThat(Doubles.stringConverter().reverse().convert(null)).isNull();
  }

  @GwtIncompatible // Double.toString returns different value in GWT.
  public void testStringConverter_reverse() {
    Converter<String, Double> converter = Doubles.stringConverter();
    assertThat(converter.reverse().convert(1.0)).isEqualTo("1.0");
    assertThat(converter.reverse().convert(0.0)).isEqualTo("0.0");

                    // Visit each unvisited node
                    allSteps().forEach(node -> visitNode(node, visited, sortedNodes));
                    // Reverse the sorted nodes to get the correct order
                    Collections.reverse(sortedNodes);
                    this.sortedNodes = sortedNodes;
                }
            }
        }
        return sortedNodes;
    }

    public void setValue(Object value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public NodeIterator childIterator(NodeTest test, boolean reverse, NodePointer startWith) {
        return new Xpp3DomNodeIterator(this, test, reverse, startWith);
    }

    @Override
    public NodeIterator attributeIterator(QName qname) {
        return new Xpp3DomAttributeIterator(this, qname);
    }

  }

  @Override
  @SuppressWarnings("nullness") // should be safe, but not sure if we can avoid the warning
  public <S extends @Nullable T> Ordering<S> reverse() {
    // ordering.reverse() might be optimized, so let it do its thing
    return ordering.<T>reverse().<@NonNull S>nullsLast();
  }

  @SuppressWarnings("unchecked") // still need the right way to explain this
  @Override

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import java.util.Iterator;

/** An ordering that uses the reverse of the natural order of the values. */
@GwtCompatible
final class ReverseNaturalOrdering extends Ordering<Comparable<?>> implements Serializable {
  static final ReverseNaturalOrdering INSTANCE = new ReverseNaturalOrdering();

                },
                if (currentReleasedVersion.gradleVersion().finalRelease()) {
                    (releasedVersions.finalReleases + currentReleasedVersion).sortedBy { it.gradleVersion() }.reversed()
                } else {
                    releasedVersions.finalReleases
                }
            )

        private
        fun newerVersion(releasedVersion: ReleasedVersion, other: ReleasedVersion) =

    }

    /** Sorts the elements in reverse natural order. */
    @SuppressWarnings("CanIgnoreReturnValueSuggester") // see ImmutableSortedSetExplicitComparator
    @Override
    public List<Integer> order(List<Integer> insertionOrder) {
      sort(insertionOrder, Ordering.<Integer>natural().reverse());
      return insertionOrder;
    }
  }