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 java.util.function.*;
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 java.awt.geom.*;
import javax.imageio.*;
import java.math.*;
import java.time.Duration;
import java.lang.invoke.VarHandle;
import java.lang.invoke.MethodHandles;
class main {

static class RegularPriceCells implements PriceCells {
  RegularPriceCells() {}
  // cell size
   final public RegularPriceCells setInterval(double interval){ return interval(interval); }
public RegularPriceCells interval(double interval) { this.interval = interval; return this; }  final public double getInterval(){ return interval(); }
public double interval() { return interval; }
 double interval;
  
  // one of the cell limits
   final public RegularPriceCells setBase(double base){ return base(base); }
public RegularPriceCells base(double base) { this.base = base; return this; }  final public double getBase(){ return base(); }
public double base() { return base; }
 double base;
  
  RegularPriceCells(double interval) {
  this.interval = interval;}
  RegularPriceCells(double base, double interval) {
  this.interval = interval;
  this.base = base;}
  
  double remainder(double price) {
    return mod(price-base, interval);
  }
  
  // TODO: not sure if this logic has rounding problems
  
  public boolean isCellLimit(double price) {
    return remainder(price) == 0;
  }
  
  public double nextCellLimit(double price) {
    double r = remainder(price);
    return price+interval-r;
  }
  
  public double previousCellLimit(double price) {
    double r = remainder(price);
    return price-(r == 0 ? interval : r);
  }
  
  public double nCellLimitsDown(double price, int n) {
    return previousCellLimit(price)-(n-1)*interval;
  }
  
  public double nCellLimitsUp(double price, int n) {
    return nextCellLimit(price)+n*interval;
  }
  
  public double priceToCellNumber(double price) {
    return (price-base)/interval;
  }
  
  public double cellNumberToPrice(double cellNumber) {
    return cellNumber*interval+base;
  }
}
// better modulo that gives positive numbers always
static int mod(int n, int m) {
  return (n % m + m) % m;
}

static long mod(long n, long m) {
  return (n % m + m) % m;
}

static BigInteger mod(BigInteger n, int m) {
  return n.mod(bigint(m));
}

static double mod(double n, double m) {
  return (n % m + m) % m;
}





static BigInteger bigint(String s) {
  return new BigInteger(s);
}

static BigInteger bigint(long l) {
  return BigInteger.valueOf(l);
}




interface PriceCells {
  boolean isCellLimit(double price);
  
  // next-higher cell limit or NaN if no more cells
  double nextCellLimit(double price);
  
  // next-lower cell limit or NaN if no more cells
  double previousCellLimit(double price);
  
  // go n steps down
  double nCellLimitsDown(double price, int n);
  
  // go n steps up
  double nCellLimitsUp(double price, int n);
  
  // convert to "cell space" (0=first cell limit, 1=next cell limit, -1=previous cell limit etc)
  default double toCellNumber(double price){ return priceToCellNumber(price); }
double priceToCellNumber(double price);
  
  default double fromCellNumber(double cellNumber){ return cellNumberToPrice(cellNumber); }
double cellNumberToPrice(double cellNumber);
}

}