import java.util.*;
import java.lang.*;
import java.text.*;

public class StringBuf0{
    static final String newLine = "\n";
    static final char   charSpace = ' ';
    static final String strSpace = " ";
    static final int windowLen = 78;
    private int Nmax, Ifield, Lspaces, indLshift, Ishift;
    private NumFormat nf, ni;
    private StringBuffer buf;

    StringBuf0(StringBuffer buf){
        this.buf = buf;
        nf = new NumFormat();  //double type formatter.
        ni = new NumFormat();  //integer type formatter.
        //These are reasonable parameters for "12.5" style format.
        setNmax(5);
        setFieldLength(12);
        setIfieldLength(12);
        setFractionDigits(5);
        setIntegerDigits(0);
        setForceExponent(false);
        setExponentDigits(2);
        setIshift(9);
        setFieldLspaces(10);
        setindLshift(3);
        setForceRightPadding(false);
    }
    //Set maximum number of columns for an output vector or matrix.
    public void setNmax(int value)
    {
        Nmax = value;
    }
    //Set double type field length.
    public void setFieldLength(int value)
    {
        Ifield = value;
        nf.setFieldLength(value);
    }
    //Set integer type field length.
    public void setIfieldLength(int value)
    {
        ni.setFieldLength(value);
    }
    //Set maximum number of digits after decimal point of double number.
    public void setFractionDigits(int value)
    {
        nf.setFractionDigits(value);
    }
    //Set maximum number of '0's to precede integer value.
    public void setIntegerDigits(int value)
    {
        ni.setIntegerDigits(0);
    }
    //Set exponential format of double values.
    public void setForceExponent(boolean force)
    {
        nf.setForceExponent(force);
    }
    //Set number of digits in exponential representation.
    public void setExponentDigits(int value)
    {
        nf.setExponentDigits(value);
    }
    public void setIshift(int value)
    {
        Ishift = value;
    }
    public void setFieldLspaces(int Lspaces)
    {
        this.Lspaces = Lspaces;
    }
    public void setindLshift(int indLshift)
    {
        this.indLshift = indLshift;
    }
    public void setForceRightPadding(boolean force)
    {
        nf.setForceRightPadding(force);
    }
    //Output a vector identified by index 'ind' to the left of it.
    public void printVec(double V[], int n, int ind)
    {
        //Execute first line shift.
        print(Ishift, ind); printSpace(1);
        printVec(V, n, n%Nmax, 0, false);
        return;
    }
    //Output a vector.
    public void printVec(double V[], int n)
    {
        //Execute first line shift.
        printSpace(Ishift); printSpace(1);
        printVec(V, n, n%Nmax, 0, false);
        return;
    }        
    public void printVec(double V[], int n, int reste, 
                         int inf, boolean getout)
    {
        int i, j, isup;
 
        isup = inf + Nmax;
        if(getout)return;
        if(isup >= n){
	      getout = true;
	      if(isup > n)isup = inf + reste;
        }
        //Execute the shift from line 2 on.
        if(inf != 0){printSpace(Ishift); printSpace(1);}
        for(i=inf; i<isup; i++)print(V[i]);
        printLine();
        inf = isup;
        printVec(V, n, reste, inf, getout); 
    }
    //
    //Output a vector. PrintInd=true will output a count index
    //above each element.
    public void printVec(double V[], int n, boolean PrintInd)
    {
        printVec(V, n, n%Nmax, 0, PrintInd, false);
        return;
    }        
    public void printVec(double V[], int n, int reste, 
                         int inf, boolean PrintInd, boolean getout)
    {
        int i, j, isup;
 
        isup = inf + Nmax;
        if(getout)return;
        if(isup >= n){
	      getout = true;
	      if(isup > n)isup = inf + reste;
        }
        if(PrintInd){
            printSpace(Lspaces-indLshift);
            for(i=inf; i<isup; i++)print(i+1);
            printLine();
        }
        printSpace(Lspaces);
        for(i=inf; i<isup; i++)print(V[i]);
        printLine();
        if(PrintInd)printLine();
        inf = isup;
        printVec(V, n, reste, inf, PrintInd, getout); 
    }
    //
    //Output a vector V identified by vector Vind. Each Vind[i] element
    //appears above the V[i] element to which it refers.
    public void printVec(double V[], Object Vind[], int n)
    {
        printVec(V, Vind, n, n%Nmax, 0, false);
        return;
    }        
    public void printVec(double V[], Object Vind[], int n,
	                   int reste, int inf, boolean getout)
    {
        int i, j, isup;
 
        isup = inf + Nmax;
        if(getout)return;
        if(isup >= n){
	      getout = true;
	      if(isup > n)isup = inf + reste;
        }
        printSpace(Lspaces-indLshift);
        for(i=inf; i<isup; i++)print(Vind[i]);
        printLine();
        printSpace(Lspaces);
        for(i=inf; i<isup; i++)print(V[i]);
        printLine(); printLine();
        inf = isup;
        printVec(V, Vind, n, reste, inf, getout); 
    }
    //Output a vector identified by index 'ind' to the left of it.
    public void output_double_vec(double vec[], int n, int ind)
    {
        int i, j=0;

        print(Ishift, ind); printSpace(1);
        for(i=0; i<n; i++){
	      print(vec[i]);

            if(++j==Nmax){
                printLine();
	          if(i != n-1){printSpace(Ishift); printSpace(1);}
	          j = 0;	
	      }
        }  
        if(j != 0)printLine();
    }
    //Output a vector.
    public void output_double_vec(double vec[], int n)
    {
        int i, j=0;

        printSpace(Ishift); printSpace(1);
        for(i=0; i<n; i++){
	      print(vec[i]);
            if(++j==Nmax){
                printLine();
	          if(i != n-1){printSpace(Ishift); printSpace(1);}
	          j = 0;	
	      }
        }  
        if(j != 0)printLine();
    }
    public void printmat(double a[][], double eig[], int nrow,
	          int ncol, boolean print_eig)
    {
        printcol(a, eig, nrow, ncol, ncol%Nmax, 0, print_eig, false);
        return;
    }        

    public void printcol(double a[][], double eig[], int nrow, int ncol,
	      int reste, int inf, boolean print_eig, boolean getout)
    {
        int i, j, isup;
 
        isup = inf + Nmax;
        if(getout){
	      getout=false;
	      return;
        }
        if(isup >= ncol){
	      getout = true;
	      if(isup > ncol)isup = inf + reste;
        }
        printSpace(Lspaces);
        for(i=inf; i<isup; i++)print(i+1);
        if(print_eig){
            printLine(); printLine(); print("EIGENVALUES-- ");
            for(i=inf; i<isup; i++)print(eig[i]);
        }
        printLine(); printLine();
        for(i=0; i<nrow; i++){
            print(i+1); printSpace(2);
            for(j=inf; j<isup; j++)print(a[i][j]);
            printLine();
        }
        printLine();
        inf = isup;
        printcol(a, eig, nrow, ncol, reste, inf, print_eig, getout); 
    }
    public void print(double number){
        String str = nf.format(number);
        print(str);
        return;
    }
    public void print(int number){
        String str = ni.format(number);
        print(str);
        return;
    }
    public void print(int Len, double number){
        int Ipad;
        Double Dnumber = new Double(number);
        String str = Dnumber.toString();
        Ipad = Len - str.length();
        printSpace(Ipad);
        print(str);
        return;
    }
    public void print(int Len, int number){
        int Ipad;
        Integer Inumber = new Integer(number);
        String str = Inumber.toString();
        Ipad = Len - str.length();
        printSpace(Ipad);
        print(str);
        return;
    }
    public void CenterString(String string, boolean underline)
    {
        int i, n, skip;

        if( (n=string.length()) == 0)return;
        skip = (windowLen - n) / 2;
        printSpace(skip);
        print(string);
        printLine();
        if(underline){
            printSpace(skip);
	      for(i=0; i<n; i++)print("-");
            printLine();
        }
        printLine();
        return;
    }
    void put_string(int shift, String string)
    {
        int i;

        printSpace(shift);
        print(string);
        return;
    }
    void dotted_line()
    {
        int i;
        printSpace(1);
        for(i=0; i<windowLen-2; i++)print("-");
        printLine();
    }
    public void printSpace(int Len)
    {
        for(int i=0; i<Len; i++)print(strSpace);
        return;
    }
    public void printLine()
    {
        print(newLine);
    }
    public void print(Object element){
        if(element instanceof String){
            print((String)element);
        }
        return;
    }
    public void print(String element){
        buf.append(element);
        return;
    }
}