codeparrot/codecomplex huggingface dataset:
// Problem: 169_A. Chores
// Time complexity: nlogn
import java.io.*;
import java.util.*;
import java.math.*;
public class A {
	@SuppressWarnings("unchecked")
	private static void solve() throws IOException {
		ArrayList<Num> c = new ArrayList<Num>();
		n = nextInt();
		a = nextInt();
		b = nextInt();
		for(int i = 0;  i < n; i++) {
			int next = nextInt();
			boolean found = false;
			for(int j = 0; j < c.size(); j++) {
				if(c.get(j).num == next) {
					c.get(j).freq++;
					found = true;
					break;
				}
			}
			if(!found)
				c.add(new Num(next));
		}
		Collections.sort(c);
		int below = 0;
		int above = n;
		boolean f = false;
		for(int i = 0; i < c.size(); i++) {
			below += c.get(i).freq;
			above -= c.get(i).freq;
			if(below == b && above == a) {
				if(i == c.size())
					break;
				System.out.println(c.get(i+1).num - c.get(i).num);
				f = true;
				break;
			}
		}
		if(!f)
			System.out.println(0);
	}
	
	static int n;
	static int a;
	static int b;
	public static void main(String[] args) {
		try {
			br = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			System.exit(239);
		}
	}

	static BufferedReader br;
	static StringTokenizer st;
	static PrintWriter out;

	static String nextToken() throws IOException {
		while (st == null || !st.hasMoreTokens()) {
			String line = br.readLine();
			if (line == null) {
				return null;
			}
			st = new StringTokenizer(line);
		}
		return st.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	static long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}
class Num implements Comparable<Num> {
	int num;
	int freq;
	Num(int n) {
		num = n;
		freq = 1;
	}
	public int compareTo(Num other) {
		return this.num - other.num;
	}
}
// Problem: 169_A. Chores
// Time complexity: nlogn
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		A solver = new A();
		solver.solve(1, in, out);
		out.close();
	}
}

class A {
	public void solve(int testNumber, InputReader in, PrintWriter out) {
        int n = in.readInt();
        int a = in.readInt();
        int b = in.readInt();
        int[] hs = new int[n];
        for (int i=0;i<n;i++){
            hs[i]=in.readInt();
        }
        Arrays.sort(hs);
        out.println(hs[b]-hs[b-1]);
	}
}

class InputReader {
    BufferedReader in;

    public InputReader(InputStream stream) {
        in = new BufferedReader(new InputStreamReader(stream));
    }

    public int skipSpace() {
        int c;
        try {
            while (true) {
                c = in.read();
                if (c < 0) {
                    throw new InputMismatchException();
                }
                if (c > 32) {
                    break;
                }
            }
        } catch (IOException e) {
            throw new InputMismatchException();
        }
        return c;
    }

    public int readInt() {
        int res = 0;
        boolean sign = false;
        int c = skipSpace();
        try {
            if (c == '-') {
                sign = true;
                c = in.read();
            }
            while (true) {
                if (c >= '0' && c <= '9') {
                    res = res * 10 + c - '0';
                } else {
                    throw new InputMismatchException();
                }
                c = in.read();
                if (c <= 32) {
                    break;
                }
            }
            if (sign) {
                res = -res;
            }
            return res;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    }
// Problem: 169_A. Chores
// Time complexity: nlogn
import java.io.*;
import java.util.*;

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";
	
	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{
		
				
			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}
	
	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}	
		catch (NullPointerException e)
		{
			line=null;
			
		}
		
	}
	
	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);
		
		//System.out.println("I read this number: " + val);
		return val;
	}
	
	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);
		
		//System.out.println("I read this number: " + val);
		return val;
	}
	
	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}
	
	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
			
	}
	
	
	public static void main(String [] argv)
	{
		String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}
	
	public void readFInput()
	{
		for(;;)
		{
			try
			{
				readNextLine();
				FInput+=line+" ";
			}
			catch(Exception e)
			{
				break;
			}
		}
		inputParser = new StringTokenizer(FInput, " ");
	}
	 
	public A(String inputFile)
	{
		openInput(inputFile);
		
		readNextLine();
		int n=NextInt();
    	int a=NextInt();
    	int b=NextInt();
		int ret=0;
		readNextLine();
		int [] p = new int[n];
		for(int i=0; i<n; i++)
		{
			p[i]=NextInt();
		}
		Arrays.sort(p);
		int id=0,cnt=0;
		while(id<n&&cnt<b)
		{
			cnt++;
			id++;
		}
		if(id<n)
		{
			ret=p[id]-p[id-1];
		}
		
		System.out.print(ret);
        closeInput();		
	}
	

}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.*;
import java.io.*;
public class a {
  static long mod = 1000000007;
  static boolean[][] blacks;
public static void main(String[] args) throws IOException
{
  input.init(System.in);
  PrintWriter out = new PrintWriter(new PrintStream(System.out));
  //Scanner input = new Scanner(new File("input.txt"));
  //PrintWriter out = new PrintWriter(new File("output.txt"));

  int n = input.nextInt(), t = input.nextInt();
  int res = 2;
  Cottage[] data = new Cottage[n];
  int[] xs = new int[n], as = new int[n];
  for(int i = 0; i<n; i++)
  {
    data[i] = new Cottage(input.nextInt(), input.nextInt());
  }
  Arrays.sort(data);
  for(int i = 0; i<n; i++)
  {
    xs[i] = data[i].x;
    as[i] = data[i].a;
  }
  for(int i = 0; i<n-1; i++)
  {
    if(2*(xs[i+1]-xs[i]) == 2*t+as[i]+as[i+1]) res++;
    else if(2*(xs[i+1]-xs[i]) > 2*t+as[i]+as[i+1]) res+=2;
  }
  out.println(res);

  out.close();
}
static class Cottage implements Comparable<Cottage>
{

  /* (non-Javadoc)
   * @see java.lang.Comparable#compareTo(java.lang.Object)
   */
  int x, a;
  public Cottage(int xx, int aa)
  {
    x = xx; a = aa;
  }
  @Override
  public int compareTo(Cottage o) {
    // TODO(mkirsche): Auto-generated method stub
    return this.x - o.x;
  }

}
static long pow(long a, long p)
{
  if(p==0) return 1;
  if((p&1) == 0)
  {
    long sqrt = pow(a, p/2);
    return (sqrt*sqrt)%mod;
  }
  else
    return (a*pow(a,p-1))%mod;
}
static class input {
  static BufferedReader reader;
  static StringTokenizer tokenizer;

  /** call this method to initialize reader for InputStream */
  static void init(InputStream input) {
      reader = new BufferedReader(
                   new InputStreamReader(input) );
      tokenizer = new StringTokenizer("");
  }

  /** get next word */
  static String next() throws IOException {
      while ( ! tokenizer.hasMoreTokens() ) {
          //TODO add check for eof if necessary
          tokenizer = new StringTokenizer(
                 reader.readLine() );
      }
      return tokenizer.nextToken();
  }

  static int nextInt() throws IOException {
      return Integer.parseInt( next() );
  }
  static long nextLong() throws IOException {
    return Long.parseLong( next() );
}

  static double nextDouble() throws IOException {
      return Double.parseDouble( next() );
  }
  static String nextLine() throws IOException {
    return reader.readLine();
  }
}
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.Random;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.io.InputStreamReader;
import java.io.File;

public class Task{
	
	static final boolean readFromFile = false;
	static final String fileInputName = "input.txt",
						fileOutputName = "output.txt";
	
	public static void main(String args[]){
		FileInputStream fileInputStream;
		FileOutputStream fileOutputStream;
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		if (readFromFile){
			try{
				fileInputStream = new FileInputStream(new File(fileInputName));
				fileOutputStream = new FileOutputStream(new File(fileOutputName));
			}catch (FileNotFoundException e){
				throw new RuntimeException(e);
			}
		}
		PrintWriter out = new PrintWriter((readFromFile)?fileOutputStream:outputStream);
		InputReader in  = new InputReader((readFromFile)?fileInputStream:inputStream);
		
		Solver s = new Solver(in, out);
		s.solve();
		
		out.close();
	}
}

class Solver{
	private PrintWriter out;
	private InputReader in;
	
	public void solve(){
		int n = in.nextInt();
		double t = in.nextDouble(),
			a[] = new double[n],
			x[] = new double[n];
		for (int i=0;i<n;i++){
			x[i] = in.nextDouble();
			a[i] = in.nextDouble();
		}
		int ans = 2;
		for (int i=0;i<n-1;i++)
			for (int j=i+1;j<n;j++)
				if (x[j]<x[i]){
					double buf = x[i];x[i]=x[j];x[j]=buf;
					buf = a[i]; a[i]=a[j];a[j]=buf;
				}
		
		for (int i=0;i<n-1;i++){
			if (x[i]+a[i]/2+t<x[i+1]-a[i+1]/2)
				ans += 2;
			if (x[i]+a[i]/2+t==x[i+1]-a[i+1]/2)
				ans++;
		}
		out.println(ans);
	}
	
	Solver(InputReader in, PrintWriter out){
		this.in = in;
		this.out = out;
	}
}

class InputReader{
	StringTokenizer tok;
	BufferedReader buf;
	
	InputReader(InputStream in){
		tok = null;
		buf = new BufferedReader(new InputStreamReader(in));
	}

	InputReader(FileInputStream in){
		tok = null;
		buf = new BufferedReader(new InputStreamReader(in));
	}
	
	public String next(){
		while (tok==null || !tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(buf.readLine());
			}catch (IOException e){
				throw new RuntimeException(e);
			}
		}
		return tok.nextToken();
	}
	
	public int nextInt(){
		return Integer.parseInt(next());
	}
	public long nextLong(){
		return Long.parseLong(next());
	}
	public double nextDouble(){
		return Double.parseDouble(next());
	}
	public float nextFloat(){
		return Float.parseFloat(next());
	}
	public String nextLine(){
		try{
			return buf.readLine();
		}catch (IOException e){
			return null;
		}
	}
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.*;


public class A {
	
	public static double EPS = .001;
	
	public class House implements Comparable<House> {
		int x;
		int a;
		
		public House(int mx, int ma) {
			x = mx;
			a = ma;
		}

		public int compareTo(House o) {
			return x - o.x;
		}
		
		public double right() {
			return (double)x + ((double)a)/2.0;
		}
		
		public double left() {
			return (double)x - ((double)a)/2.0;
		}
	}
	
	public static void main(String[] args) {
		new A().solve();
	}
	
	
	public void solve() {
		Scanner in = new Scanner(System.in);
		
		int n = in.nextInt();
		int t = in.nextInt();
		
		ArrayList<House> houses = new ArrayList<House>();
		
		for(int i=0;i<n;i++) {
			int x = in.nextInt();
			int a = in.nextInt();
			houses.add(new House(x,a));
		}
		
		Collections.sort(houses);
		
		
		int total = 2;
		
		for(int i=0;i<houses.size()-1;i++) {
			House me = houses.get(i);
			House next = houses.get(i+1);
			double meright = me.right();
			double nextleft = next.left();
			double diff = nextleft - meright;
			if(diff-EPS > ((double)t)) {
				total += 2;
			}
			else if(diff+EPS > ((double)t)) {
				total += 1;
			}
		}
		
		System.out.println(total);
	}
	
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.*;

public class Village {
	private class House implements Comparable<House>{
		Double Coordinate;
		Double Sidelength;
		public House(double coordinate, double sidelength) {
			Coordinate = coordinate;
			Sidelength = sidelength;
		}
		public int compareTo(House o) {
			return Coordinate.compareTo(o.Coordinate);
		}
	}
	
	
	public static void main(String args[]) {
		Village v = new Village();
		v.solve();
	}
	public void solve() {
	Scanner in = new Scanner(System.in);
	int numhouse = in.nextInt();
	double requireside = in.nextDouble();
	//System.out.println(numhouse);
	//System.out.println(requireside);		
	ArrayList<House> coordinate = new ArrayList<House>();
	ArrayList<Double> sidelength = new ArrayList<Double>();	
	while (in.hasNext()) {
		double coo = in.nextDouble();
		double side = in.nextDouble();
		//System.out.println(coo);
		//System.out.println(side);
		coordinate.add(new House(coo,side));
		sidelength.add(side);
		}
	Collections.sort(coordinate);
	ArrayList<Double> edges = new ArrayList<Double>();
	int count = 2;
	for (int i = 0; i < coordinate.size();i++) {
		edges.add(coordinate.get(i).Coordinate - (double)coordinate.get(i).Sidelength/(double)2);
		edges.add(coordinate.get(i).Coordinate + (double)coordinate.get(i).Sidelength/(double)2);
	}
	ArrayList<Double> difference = new ArrayList<Double>();
	for (int i = 1; i < edges.size() - 1; i++) {
		difference.add(Math.abs(edges.get(i) - edges.get(i+1)));
	}
	for (int i = 0; i < difference.size(); i+=2) {
		if (difference.get(i) == requireside) count++;
		else if (difference.get(i) > requireside) count+=2;
	}
	System.out.println(count);
	}
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class A15 {

	static StreamTokenizer in;
	static PrintWriter out;
	
	static int nextInt() throws IOException {
		in.nextToken();
		return (int)in.nval;
	}
	
	static String nextString() throws IOException {
		in.nextToken();
		return in.sval;
	}

	public static void main(String[] args) throws IOException {
		in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		out = new PrintWriter(System.out);
		
		int n = nextInt(), t = nextInt();
		
		int[] x = new int[n];
		int[] a = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = nextInt();
			a[i] = nextInt();
		}
		
		int ans = 0;
		for (int i = 0; i < n; i++) {
			boolean left = true, right = true;
			for (int j = 0; j < n; j++)
				if (x[j] < x[i] && a[i] + 2*t + a[j] >= 2*Math.abs(x[i] - x[j])) left = false;
				else if (x[j] > x[i] && a[i] + 2*t + a[j] > 2*Math.abs(x[i] - x[j])) right = false;
			if (left) ans++;
			if (right) ans++;
		}
		
		out.println(ans);
		
		out.flush();
	}
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn

import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author madi
 */
public class CottageTown {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] in = sc.nextLine().split(" ");
        int n = Integer.parseInt(in[0]);
        int t = Integer.parseInt(in[1]);

        int[] coor = new int[n];
        int[] side = new int[n];

        for (int i = 0; i < n; i++) {
            in = sc.nextLine().split(" ");
            coor[i] = Integer.parseInt(in[0]);
            side[i] = Integer.parseInt(in[1]);
        }

        quickSort(coor, 0, n - 1, side);

        int count = 2;
        double dist;
        for (int i = 0; i < n - 1; i++) {
            dist = (coor[i + 1] - coor[i]) - (double)(side[i + 1] + side[i]) / 2.0;
            if (dist > t) {
                count += 2;
            } else if (dist == t) {
                count += 1;
            }
        }

        System.out.println(count);

    }

    private static int partition(int[] arr, int left, int right, int[] temp) {
        int i = left, j = right;
        int tmp;
        int pivot = arr[(left + right) / 2];

        while (i <= j) {
            while (arr[i] < pivot) {
                i++;
            }
            while (arr[j] > pivot) {
                j--;
            }
            if (i <= j) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;

                tmp = temp[i];
                temp[i] = temp[j];
                temp[j] = tmp;

                i++;
                j--;
            }
        }

        return i;
    }

    private static void quickSort(int[] arr, int left, int right, int[] temp) {
        int index = partition(arr, left, right, temp);
        if (left < index - 1) {
            quickSort(arr, left, index - 1, temp);
        }
        if (index < right) {
            quickSort(arr, index, right, temp);
        }
    }
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn

import java.util.Scanner;


public class Flatwile {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int t = sc.nextInt();
        int[] c = new int[n];
        int[] a = new int[n];
        for (int i=0; i<n; i++){
            c[i] = sc.nextInt();
            a[i] = sc.nextInt();
        }
        sort(c, a);
        int res = 1;
        double prev = Integer.MIN_VALUE;
        for(int i=0; i<c.length; i++){
            if (c[i]-a[i]/2d - prev >=t){
                res++;
            }
            if (i!=c.length-1 && c[i+1]-a[i+1]/2d-(c[i]+a[i]/2d)>t ){
                res++;
            }
            prev = c[i] +a[i]/2d;
        }
        System.out.println(res);
    }

    private static void sort(int[] a, int[] b){
        for(int i=0; i<a.length; i++){
            for(int j=i+1; j<a.length; j++){
                if (a[i]>a[j]){
                    swap(a, i, j);
                    swap(b, i, j);
                }
            }
        }
    }

    private static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        new A().solve();
    }
    
    public void solve() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int t = sc.nextInt();
        float[] left = new float[n];
        float[] right = new float[n];
        for (int i=0; i<n; ++i) {
            int c = sc.nextInt();
            int w = sc.nextInt();
            left[i] = (float) (c - (float) w * 1.0 / 2);
            right[i] = (float) (c + (float) w * 1.0 / 2);
        }
        for (int i=0; i<n; ++i)
            for (int j=i+1; j<n; ++j)
                if (left[j] < left[i]) {
                    float tmp = left[i];
                    left[i] = left[j];
                    left[j] = tmp;
                    tmp = right[i];
                    right[i] = right[j];
                    right[j] = tmp;
                }
        int res = 2;
        for (int i=1; i<n; ++i) {
            float dis = left[i] - right[i-1];
            if (Math.abs(dis - t) < 0.000001)
                res ++;
            if ((dis - t) > 0.000001)
                res += 2;
        }
        System.out.println(res);
    }
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class Houses implements Runnable {
    private void solve() throws IOException {
        int n = nextInt();
        int t = nextInt();
        int[] x = new int[n];
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            x[i] = nextInt() * 2;
            a[i] = nextInt();
        }
        Set<Integer> res = new HashSet<Integer>();
        for (int i = 0; i < n; ++i) {
            if (valid(n, t, x, a, x[i] + a[i] + t))
                res.add(x[i] + a[i] + t);
            if (valid(n, t, x, a, x[i] - a[i] - t))
                res.add(x[i] - a[i] - t);
        }
        writer.println(res.size());
    }

    private boolean valid(int n, int t, int[] x, int[] a, int pos) {
        for (int i = 0; i < n; ++i) {
            if (Math.abs(pos - x[i]) < a[i] + t)
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        new Houses().run();
    }

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}
// Problem: 15_A. Cottage Village
// Time complexity: nlogn
import java.util.*;
public class C15A {
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int t=sc.nextInt();
        double nm[][]=new double[n][2];
        int a=0;
        int b=0;
        for(int i=0;i<n;i++){
            a=sc.nextInt();
            b=sc.nextInt();
            nm[i][0]=a-(double)b/2;
            nm[i][1]=a+(double)b/2;
        }


        Arrays.sort(nm, new ArrayColumnComparator(1));

        int sum=0;
        for(int i=0;i<n-1;i++){
            if(nm[i+1][0]-nm[i][1]==t)
                sum++;
            else if(nm[i+1][0]-nm[i][1]>t){
                sum+=2;
            }

        }

        System.out.println(sum+2);
    }

}
class ArrayColumnComparator implements Comparator {
    private int cm = 0;
    ArrayColumnComparator(int cm) {
        this.cm = cm;
    }
    public int compare(Object o1, Object o2) {
        double[] row1 = (double[])o1;
        double[] row2 = (double[])o2;
        int i;
        if (row1[cm]>row2[cm])
            i=1;
        else if(row1[cm]<row2[cm])
            i=-1;
        else i=0;
        return i;
    }
}