import java.util.*;
import java.util.zip.*;
import java.util.List;
import java.util.regex.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.concurrent.locks.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import javax.swing.table.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;
import java.lang.ref.*;
import java.lang.management.*;
import java.security.*;
import java.security.spec.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import javax.imageio.*;
import java.math.*;
class main {

static int indexOfIntPairInContentsIndexedList(IContentsIndexedList2<Integer> l, Integer pa, Integer pb, int idx) {
  SortedSet<HasIndex> setA = l.indicesOf_treeSetOfHasIndex(pa);
  if (setA == null) return -1;
  SortedSet<HasIndex> setB = l.indicesOf_treeSetOfHasIndex(pb);
  if (setB == null) return -1;
  
  // Take size now because size of a tailSet is costly to compute
  if (setA.size() <= setB.size()) {
    // quickly skip entries left of idx
    if (idx > 0)
      setA = setA.tailSet(new HasIndex(idx));

    // scan set, check if it's a pair
    int n = l.size();
    for (HasIndex hi : setA) {
      int i = hi.idx;
      if (i+1 < n && eq(l.get(i+1), pb))
        return i;
    }
  } else {
    // quickly skip entries left of idx+1
    setB = setB.tailSet(new HasIndex(idx+1));
    
    // scan set, check if it's a pair
    for (HasIndex hi : setB) {
      int i = hi.idx;
      if (eq(l.get(i-1), pa))
        return i-1;
    }
  }
  
  return -1;
}
static boolean eq(Object a, Object b) {
  return a == b || (a == null ? b == null : b != null && a.equals(b));
}




static String str(Object o) {
  return o == null ? "null" : o.toString();
}

static String str(char[] c) {
  return new String(c);
}


static interface IContentsIndexedList2<A> extends List<A> {
  TreeSet<HasIndex> indicesOf_treeSetOfHasIndex(Object o);
}static class HasIndex implements Comparable<HasIndex> {
  int idx;
  
  HasIndex() {}
  HasIndex(int idx) {
  this.idx = idx;}
  
  public int compareTo(HasIndex h) {
    return idx-h.idx;
  }
}
}