class GFG { 
  
    // Driver's code 
    public static void main(String[] args) 
    { 
        // Creating a List of Integers 
        List<Integer> myList 
            = Arrays.asList(1, 2, 3, 4, 5); 
  
        // Using Lists.reverse() method to get a 
        // reversed view of the specified list. Any 
        // changes in the returned list are reflected 
        // in the original list and vice-versa 
        List<Integer> reverse = Lists.reverse(myList); 
  
        // Displaying the reversed view of specified List 
        System.out.println(reverse); 
    } 
} 

        

public void whenReverseList_thenReversed() {
    List<String> names = Lists.newArrayList("John", "Adam", "Jane");
 
    List<String> reversed = Lists.reverse(names);
    assertThat(reversed, contains("Jane", "Adam", "John"));
}



        

class ListUtils
{
	// Java program to demonstrate Guava's Lists.reverse() method
	public static void main(String[] args)
	{
		List<Integer> mutableList = Arrays.asList(1, 2, 3, 4, 5);

		List<Integer> reverse = Lists.reverse(mutableList);
		System.out.println(reverse);
	}
}

        

public static void main(String[] args)  {
	List<String> letters = ImmutableList.of("a", "b", "c");
	List<String> reverseView = Lists.reverse(letters); 
	System.out.println(reverseView); // [c, b, a]
}

        

class GFG { 
  
    // Driver's code 
    public static void main(String[] args) 
    { 
        // Creating a List of Characters 
        List<Character> myList 
            = Arrays.asList('H', 'E', 'L', 'L', 'O'); 
  
        // Using Lists.reverse() method to get a 
        // reversed view of the specified list. Any 
        // changes in the returned list are reflected 
        // in the original list and vice-versa 
        List<Character> reverse = Lists.reverse(myList); 
  
        // Displaying the reversed view of specified List 
        System.out.println(reverse); 
    } 
}

        

public void addSecurityRules ( final Rules rules, final IProgressMonitor monitor )
{
    if ( rules == null )
    {
        return;
    }

    int priority = 1000;

    monitor.beginTask ( "Encoding security rules", rules.getRules ().size () );

    for ( final Rule rule : Lists.reverse ( rules.getRules () ) )
    {
        final RuleEncoder encoder = RuleEncoder.findEncoder ( rule );
        if ( encoder != null )
        {
            encoder.encodeRule ( this.ctx, priority += 100 );
        }
        monitor.worked ( 1 );
    }

    monitor.done ();
}

        

public void prepare() {
    this.finalDownstream.prepare();
    for (Projector projector : Lists.reverse(nodeProjectors)) {
        projector.prepare();
    }
    if (shardProjectionsIndex >= 0) {
        for (Projector p : shardProjectors) {
            p.prepare();
        }
    }
}

        

public BigInteger getYValue(BigInteger x, List<BigInteger> bold_a) {
    Preconditions.checkArgument(bold_a.size() >= 1,
            String.format("The size of bold_a should always be larger or equal to 1 (it is [%d]", bold_a.size()));
    if (x.equals(BigInteger.ZERO)) {
        return bold_a.get(0);
    } else {
        BigInteger y = BigInteger.ZERO;
        for (BigInteger a_i : Lists.reverse(bold_a)) {
            y = a_i.add(x.multiply(y).mod(primeField.getP_prime())).mod(primeField.getP_prime());
        }
        return y;
    }
}

        

void render(PerformanceTestHistory testHistory, Transformer<String, MeasuredOperationList> valueRenderer, PrintWriter out) {
    List<? extends PerformanceTestExecution> sortedResults = Lists.reverse(testHistory.getExecutions());
    out.println("  [");
    List<String> labels = testHistory.getScenarioLabels();
    for (int i = 0; i < labels.size(); i++) {
        if (i > 0) {
            out.println(",");
        }
        out.println("  {");
        out.println("    \"label\": \"" + labels.get(i) + "\",");
        out.print("\"data\": [");
        boolean empty = true;
        for (int j = 0; j < sortedResults.size(); j++) {
            PerformanceTestExecution results = sortedResults.get(j);
            MeasuredOperationList measuredOperations = results.getScenarios().get(i);
            if (!measuredOperations.isEmpty()) {
                if (!empty) {
                    out.print(", ");
                }
                out.print("[" + j + ", " + valueRenderer.transform(measuredOperations) + "]");
                empty = false;
            }
        }
        out.println("]");
        out.print("  }");
    }
    out.println();
    out.println("]");
}

        

private String getErrorMessage(String initMsg) {
    List<String> locators = Lists.reverse(getLocators());
    if (locators.size() > 0) {
        initMsg += ": ";
        StringJoiner joiner = new StringJoiner(", ");
        for (String loc : locators) {
            joiner.add(loc);
        }
        initMsg += joiner.toString();
    }
    initMsg += " " + configError;
    return initMsg;
}