Total Comparison Cephalopod.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5dbda5d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "from read_roi import read_roi_zip\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import kstest\n",
    "import os\n",
    "import rawpy\n",
    "from numpy.fft import fft2,ifft2,fftshift,ifftshift,fftfreq\n",
    "from scipy.stats import ks_2samp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "01e2cbe5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CLEAN(image,mask,gain=0.5,maxsteps=15000,limit=2,convcheck=10,variant=\"standard\"):\n",
    "    '''\n",
    "    Takes an image and a binary mask, and fills in region outside the mask using the CLEAN algorithm\n",
    "    \n",
    "    image: input image\n",
    "    mask: binary mask, 1 in region of data and 0 in background\n",
    "    gain: fraction of peak to add to the clean map\n",
    "    maxsteps: maximum number of cleaning loops to run\n",
    "    limit: maximum acceptable standard deviation of the final remainder\n",
    "    convcheck: how many loops should run before checking the convergence condition\n",
    "    variant: \"original\" or \"replace\", whether or not the final product should be identical to the original in the \n",
    "        binary mask\n",
    "        \n",
    "    Output: cleanmap: the CLEANed image\n",
    "    '''\n",
    "    \n",
    "    from numpy import fft\n",
    "    converged=False\n",
    "    nsteps=1\n",
    "    maxes=[] #initialize list of maximums\n",
    "    origimg=image #save for later\n",
    "    \n",
    "    #rescale image to odd: extra pixel in even is unaccounted for.\n",
    "    (width,height)=mask.shape\n",
    "        \n",
    "    cleanmap=np.zeros(mask.shape,dtype=np.csingle) #initialize clean map\n",
    "    \n",
    "    residual=fftshift(fft2(image)) #set residual as FFT\n",
    "    mask_fft=fftshift(fft2(mask)) #set mask as FFT of original \n",
    "    \n",
    "    xwl=fftshift(fftfreq(width)) #get frequencies at each axis\n",
    "    ywl=fftshift(fftfreq(height))\n",
    "    \n",
    "    W0=np.max(mask_fft) #central value of the mask is always the maximum \n",
    "\n",
    "    while not converged and nsteps<maxsteps:\n",
    "        maxes.append(np.max(np.abs(residual)))\n",
    "        coord=np.where(np.abs(residual)==np.max(np.abs(residual))) #coordinates of the maximum value of the residual\n",
    "        coord=np.array([coord[0][0],coord[1][0]]) #take the first one WLOG\n",
    "        \n",
    "        coord2=np.array([(2*coord[0]-int(width/2))%width,(2*coord[1]-int(height/2))%height]) #compute the second coordinate in the convolution due to symmetry, python wraps around\n",
    "        \n",
    "        xfq=xwl[coord[0]];yfq=ywl[coord[1]] #compute frequency for finding of singular points\n",
    "        if ((xfq==-0.5)|(xfq==0))&((yfq==-0.5)|(yfq==0)): #if maximum is a singular point\n",
    "            a = gain*residual[coord[0],coord[1]]/W0\n",
    "            mask_roll=np.roll(mask_fft,(coord[0]-int(width/2)),axis=0) #roll the matrix along the 0th axis\n",
    "            mask_roll=np.roll(mask_roll,(coord[1]-int(height/2)),axis=1) #then the first\n",
    "            residual=residual-(a*mask_roll)\n",
    "            cleanmap[coord[0],coord[1]]=cleanmap[coord[0],coord[1]]+(a*width*height) #compute the spike and add back in. size is used here to simplify\n",
    "        else: #residual max is in another location\n",
    "            a=residual[coord[0],coord[1]] #value of residual spike\n",
    "            W2=mask_fft[coord2[0],coord2[1]] #mask values at second coordinate\n",
    "            impulse=gain*height*width*(a*W0-np.conj(a)*W2)/(W0**2-W2*np.conj(W2)) #compute impulse from backcorrected convolution\n",
    "            #print(\"computed impulse:\",impulse)\n",
    "            \n",
    "            mask_up=np.roll(mask_fft,(coord[0]-int(width/2)),axis=0) #roll the matrix along the 0th axis\n",
    "            mask_up=np.roll(mask_up,(coord[1]-int(height/2)),axis=1) #then the first\n",
    "\n",
    "            mask_down=np.roll(mask_fft,-(coord[0]-int(width/2)),axis=0) #then back down. This produces mirrored values for \n",
    "            mask_down=np.roll(mask_down,-(coord[1]-int(height/2)),axis=1) #the subtraction\n",
    "            correction=(impulse*mask_up+np.conj(impulse)*mask_down)/(width*height) #this is the corrected matrix\n",
    "            \n",
    "            residual=residual-correction #correct residual\n",
    "            \n",
    "            negcoord=np.array([(2*int(width/2)-coord[0])%width,(2*int(height/2)-coord[1])%height]) #find coordinates at opposite points\n",
    "            \n",
    "            cleanmap[coord[0],coord[1]]=cleanmap[coord[0],coord[1]]+impulse #add component to clean map\n",
    "            cleanmap[negcoord[0],negcoord[1]]=cleanmap[negcoord[0],negcoord[1]]+np.conj(impulse) #add conj component to clean map\n",
    "        if nsteps%10==0:print(\"NSteps:\",nsteps,end='\\r')\n",
    "        if nsteps%convcheck==0: #check for convergence every convcheck cycles\n",
    "            if (np.max(np.abs(residual))-np.mean(np.abs(residual)))/np.std(np.abs(residual))<=limit: #if the std is small compared to the mean, assume dropoff has slowed to the point of stopping\n",
    "                converged=True\n",
    "                print(\"CONVERGED, NSTEPS:\",nsteps)\n",
    "            else: maxes=[] #reset if false\n",
    "        nsteps+=1\n",
    "    if variant==\"replace\":\n",
    "        def imgSSE(x,*args):\n",
    "            return(np.sum(np.abs(args[0]*x[0]+x[1]-args[1])))\n",
    "\n",
    "        cleanimg=np.real(ifft2(ifftshift(cleanmap)))\n",
    "        coord=np.where(mask!=0)\n",
    "        cleanlist=cleanimg[coord]\n",
    "        origlist=origimg[coord]\n",
    "        from scipy.optimize import minimize\n",
    "        a,b=minimize(imgSSE,(1,0),args=(cleanlist,origlist)).x\n",
    "        cleanimg=a*cleanimg+b\n",
    "        cleanimg=np.where(mask!=0,origimg,cleanimg)\n",
    "        cleanmap=fftshift(fft2(cleanimg))\n",
    "    \n",
    "    if nsteps==maxsteps:\n",
    "        print(\"FINISHED WITHOUT CONVERGING\")\n",
    "    return(np.real(ifft2(ifftshift(cleanmap))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ab3ae435",
   "metadata": {},
   "outputs": [],
   "source": [
    "def powerSpectrum(image,nbins):\n",
    "    '''\n",
    "    Computes the power spectrum of an input image. Bins are logarithmically spaced. \n",
    "    \n",
    "    Inputs:\n",
    "        image: input image for analysis\n",
    "        nbins: number of exponential bins for the spectrum to be simplified to\n",
    "        \n",
    "    Outputs: (Pkj, kaj)\n",
    "        Pkj: power spectrum data\n",
    "        kaj: average wavenumber of each bin. \n",
    "    \n",
    "    '''\n",
    "    width,height=image.shape\n",
    "    delta=fft2(image)\n",
    "    N2=width*height\n",
    "    \n",
    "    k1x=fftfreq(width)*2.0*np.pi\n",
    "    k1y=fftfreq(height)*2.0*np.pi\n",
    "    kx, ky = np.meshgrid(k1x, k1y)\n",
    "    k = np.sqrt(kx**2 + ky**2)\n",
    "    k[0,0]=2*np.pi\n",
    "    \n",
    "    lk = np.log10(k)\n",
    "    Pkj,  lkj = np.histogram(lk, bins=nbins, weights=np.square(np.absolute(delta)), density=False) \n",
    "    lkaj, lkj = np.histogram(lk, bins=nbins, weights=lk, density=False) \n",
    "    nj , lkj  = np.histogram(lk, bins=nbins, density=False) \n",
    "    # P(k) and its rms Poisson error due to finite number of modes\n",
    "    \n",
    "    #b=-1;test=np.real(ifft2(np.where((lk>=lkj[b]),delta,0)));plt.imshow(test);plt.show() #show this band's ifft. use to determine if the band is useful\n",
    "    #print(np.max(test))\n",
    "    \n",
    "    Pkj = Pkj / nj / N2\n",
    "    lkaj = lkaj / nj \n",
    "    kaj = 10.**lkaj\n",
    "    return(Pkj,kaj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5607cef1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def physPower(image,mask,mode=\"STD\"):\n",
    "    '''\n",
    "    Compute the physical (non-Fourier) power spectrum of the image for a given mask, \n",
    "    in the method of the MICA toolbox. Bins are logarithmically spaced. \n",
    "    \n",
    "    Inputs: \n",
    "        image: input image for analysis\n",
    "        mask: binary mask specifying the region for analysis. \n",
    "        mode: way of computing the power of each band. Options are 'STD' and 'SQR', \n",
    "            which take the standard deviation and the sum of squares respectively\n",
    "            \n",
    "    Output: physical power spectrum of the image\n",
    "        \n",
    "    '''\n",
    "    width,height=image.shape\n",
    "    delta=fft2(image)\n",
    "    mask=mask*np.mean(image[np.where(mask!=0)])/np.max(mask)\n",
    "    mfft=fft2(mask)\n",
    "    N2=width*height\n",
    "    \n",
    "    output=[]\n",
    "    \n",
    "    k1x=width*fftfreq(width)*2.0*np.pi\n",
    "    k1y=height*fftfreq(height)*2.0*np.pi\n",
    "    kx, ky = np.meshgrid(k1x, k1y)\n",
    "    k = np.sqrt(kx**2 + ky**2)\n",
    "    k[0,0]=2*np.pi\n",
    "    \n",
    "    n=int(2*(np.log2(k[int(width/2),int(height/2)])-1))\n",
    "    \n",
    "    lkj=np.logspace(2,(n+2),num=(n+1),base=np.sqrt(2))\n",
    "    \n",
    "    for ind in range(n):\n",
    "        map1=np.where(((k>=lkj[ind])&(k<lkj[ind+1])),delta,0)\n",
    "        map2=np.where(((k>=lkj[ind])&(k<lkj[ind+1])),mfft,0)\n",
    "        if mode==\"STD\": output.append(np.std(np.real(ifft2(map1)-ifft2(map2))))\n",
    "        if mode==\"SQR\": output.append(np.sum(np.square(np.real(ifft2(map1)-ifft2(map2))))/N2)\n",
    "    return(np.array(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6f506fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def unifBack(img,mask,variant):\n",
    "    '''\n",
    "    Fills the background (non-data) region of the image with a uniform value\n",
    "    \n",
    "    Inputs:\n",
    "        img: input image\n",
    "        mask: binary mask, with 1 in data and 0 in non-data regions\n",
    "        variant: 'mean' or 'black', which fill the background with the mean of the data and 0, respectively\n",
    "    '''\n",
    "    if variant==\"mean\":\n",
    "        fill=np.mean(img[np.where(mask!=0)])\n",
    "    elif variant==\"black\":\n",
    "        fill=0\n",
    "    output=fill*np.ones((img.shape))\n",
    "    output[np.where(mask!=0)]=img[np.where(mask!=0)]\n",
    "    return(output)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3d2031c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def randBack(img,mask):\n",
    "    '''\n",
    "    Fills the non-data region with random selections from the data region, with Gaussian smoothing.  \n",
    "    \n",
    "    Inputs: \n",
    "        img: The image to be modified\n",
    "        mask: The binary mask, where 1 is data and 0 is non-data. \n",
    "    '''\n",
    "    coord=np.where(mask!=0)\n",
    "    data=img[coord]\n",
    "\n",
    "    emptcoord=np.where(mask==0)\n",
    "    output=np.zeros((img.shape))\n",
    "    length=output[emptcoord].size\n",
    "    output[emptcoord]=data[np.random.choice(len(data),length,replace=True)]\n",
    "    import scipy.ndimage as ndimage\n",
    "    output=ndimage.gaussian_filter(output, sigma=(1, 1), order=0)\n",
    "    output[coord]=data\n",
    "    return(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1814e9fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rectArea(img):\n",
    "    #cuts out a random square region of an input image, setting all other data to 0\n",
    "    x,y=np.random.randint(0,43,size=2)\n",
    "    mask=np.zeros(img.shape)\n",
    "    mask[x:(x+85),y:(y+85)]=1\n",
    "    return(np.multiply(img,mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e870e1fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chi2(E,x): #computes the chi2 difference between the inputs\n",
    "    return(np.sum(np.square(x-E)/E))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "007c8e82",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumdiff(x,y): #computes the sum of the differences\n",
    "    return(np.sum(np.abs(x-y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cf3c532e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def SSE(x,y): #computes the sum of the squared errors\n",
    "    return(np.sum(np.square(x-y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "21663479",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Processor(args,version=\"KS\",el=-1):\n",
    "    '''\n",
    "    Processes and computes the matching percentages for each different comparison method.\n",
    "    \n",
    "    Inputs: \n",
    "        args: a tuple of lists of images to compare, with the first being the original.\n",
    "        version: comparison method, can be physical power spectra ('STD' or 'SQR') or \n",
    "        power spectra (chi2','SAD','SSE')\n",
    "        el: the last point in the spectrum. set to None if you want all of them, usually set to -1, \n",
    "            since the last band tests to have non-visible data\n",
    "    '''\n",
    "    import string\n",
    "    names=np.array(list(string.ascii_lowercase)[0:len(args)-1])\n",
    "    rank=np.zeros((len(args[0]),len(args)-1),dtype=str)\n",
    "    means=np.zeros(len(args[0]));stds=np.zeros(len(args[0]))\n",
    "    \n",
    "    for index in range(len(args[0])):\n",
    "        if index%10==0: print(\"Processing:\",index,\"/\",len(args[0]),end='\\r')\n",
    "        oimg=args[0][index]\n",
    "        if (version==\"STD\")or(version==\"SQR\"):\n",
    "            ospec=physPower(oimg,np.ones(oimg.shape),version)\n",
    "        else:\n",
    "            opkj,kaj=powerSpectrum(oimg,10)\n",
    "            opkj=opkj[0:el];kaj=kaj[0:el]               \n",
    "            opkj=np.log(opkj) #computes with the logarithm\n",
    "            \n",
    "        chiarr=np.zeros(len(args)-1)\n",
    "        for imgind in range(len(args)-1):\n",
    "            image=args[imgind+1][index]\n",
    "            if (version==\"STD\")or(version==\"SQR\"):\n",
    "                mask=np.where(image!=0,1,0)\n",
    "                tspec=physPower(image,mask,version)\n",
    "                chiarr[imgind]=sumdiff(ospec/np.sum(ospec),tspec/np.sum(tspec))\n",
    "            else:\n",
    "                tpkj,kaj=powerSpectrum(image,10)\n",
    "                tpkj=tpkj[0:el];kaj=kaj[0:el]               \n",
    "                tpkj=np.log(tpkj) #computes with the logarithm\n",
    "                if version==\"KS\":\n",
    "                    chiarr[imgind]=1-ks_2samp(opkj,tpkj).pvalue\n",
    "                if version==\"chi2\":\n",
    "                    chiarr[imgind]=chi2(opkj,tpkj)\n",
    "                if version==\"SAD\":\n",
    "                    chiarr[imgind]=sumdiff(opkj,tpkj)\n",
    "                if version==\"SSE\":\n",
    "                    chiarr[imgind]=SSE(opkj,tpkj)\n",
    "\n",
    "        rank[index,:]=names[np.argsort(chiarr)]\n",
    "        means[index]=np.mean(chiarr);stds[index]=np.std(chiarr)\n",
    "        \n",
    "    final=np.zeros(len(args)-1)\n",
    "    for i in range(len(names)):\n",
    "        final[i]=100*np.sum(rank[:,0]==names[i])/len(args[0])\n",
    "    return(final,np.median(means),np.median(stds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "4d367dc6",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-83-6f122eced28c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[0mimage\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mrawpy\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;34m\".CR2\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m     \u001b[0mimage\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpostprocess\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#Loads in the data for analysis\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     14\u001b[0m     \u001b[0mimage\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcv2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcvtColor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcv2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mCOLOR_RGB2GRAY\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#THIS GENERATES THE OCTOPUS SUB-IMAGES\n",
    "path=os.getcwd()+\"\\Data\\\\\"\n",
    "filelist=os.listdir(path)\n",
    "\n",
    "subpath=os.getcwd()+\"\\Sub-Data\\\\\"\n",
    "\n",
    "for name in filelist: \n",
    "    name=name.split(\".\")\n",
    "    if name[-1]==\"zip\": continue\n",
    "    name=name[0]\n",
    "\n",
    "    image=rawpy.imread(path+name+\".CR2\")\n",
    "    image=image.postprocess() #Loads in the data for analysis\n",
    "    image=cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
    "    \n",
    "    roiset=read_roi_zip(path+name+\".zip\")\n",
    "    ind=0\n",
    "    for roi in roiset:\n",
    "        roi=roiset[roi]\n",
    "        left,top=roi['left'],roi['top']\n",
    "        width,height=roi['width'],roi['height']\n",
    "        subimg=image[top:(top+height),left:(left+width)]\n",
    "        \n",
    "        cv2.imwrite((subpath+name+\"_\"+str(ind)+\".tiff\"),subimg)\n",
    "        ind+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1d8eace8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#READS IN ROIS \n",
    "rois=read_roi_zip(os.getcwd()+\"\\\\RoiSet.zip\")\n",
    "roiarr=np.empty((15,),dtype=object)\n",
    "i=0\n",
    "for ind in rois:\n",
    "    roi=rois[ind]\n",
    "    pts=np.array([roi['x'],roi['y']],dtype=np.int32).T\n",
    "    mask=np.zeros((128,128))\n",
    "    cv2.fillPoly(mask,[pts],1)\n",
    "    roiarr[i]=mask\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "20623824",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1434\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visual Test\n",
    "subpath=os.getcwd()+\"\\Sub-Data\\\\\" #set path of subimages\n",
    "filelist=os.listdir(subpath) #list subimages\n",
    "print(len(filelist))\n",
    "name=filelist[np.random.randint(0,len(filelist))] #grab random file\n",
    "mask=roiarr[np.random.randint(0,15)] #grab random mask\n",
    "\n",
    "image=cv2.imread(subpath+name)\n",
    "image=cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import ImageGrid\n",
    "\n",
    "fig=plt.figure(figsize=(15,15))\n",
    "\n",
    "grid = ImageGrid(fig, 111,  # similar to subplot(111)\n",
    "                 nrows_ncols=(4, 2),  # creates 2x2 grid of axes\n",
    "                 axes_pad=0.1,  # pad between axes in inch.\n",
    "                 )\n",
    "axmat=[]\n",
    "for ax in grid:\n",
    "    axmat.append(ax)\n",
    "axmat[0].imshow(image,cmap='gray')\n",
    "\n",
    "test=rectArea(image)\n",
    "axmat[1].imshow(test,cmap='gray')\n",
    "\n",
    "test=unifBack(image,mask,\"black\")\n",
    "axmat[2].imshow(test,cmap='gray')\n",
    "\n",
    "test=unifBack(image,mask,\"mean\")\n",
    "axmat[3].imshow(test,cmap='gray')\n",
    "\n",
    "test=randBack(image,mask)\n",
    "axmat[4].imshow(test,cmap='gray')\n",
    "\n",
    "cimg=np.multiply(image,mask)\n",
    "test=CLEAN(cimg,mask,variant=\"standard\")\n",
    "axmat[5].imshow(test,cmap='gray')\n",
    "\n",
    "test=CLEAN(cimg,mask,variant=\"replace\")\n",
    "axmat[6].imshow(test,cmap='gray');plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f43cbaa5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 30700 2900\n",
      "CONVERGED, NSTEPS: 30702210\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 30206002690 2990\n",
      "CONVERGED, NSTEPS: 29704026202720\n",
      "CONVERGED, NSTEPS: 29701310196022602870 2970\n",
      "CONVERGED, NSTEPS: 254030\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2390760\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 222014602150\n",
      "CONVERGED, NSTEPS: 2730243025302630\n",
      "CONVERGED, NSTEPS: 27302021402670\n",
      "CONVERGED, NSTEPS: 271024602570\n",
      "CONVERGED, NSTEPS: 271017601850\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920730\n",
      "CONVERGED, NSTEPS: 315060132018202970\n",
      "CONVERGED, NSTEPS: 3150100\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 30400\n",
      "CONVERGED, NSTEPS: 289020 1140\n",
      "CONVERGED, NSTEPS: 289001490 16801900 2010 2440 2540\n",
      "CONVERGED, NSTEPS: 263002440\n",
      "CONVERGED, NSTEPS: 2630020802170\n",
      "CONVERGED, NSTEPS: 25900 24802570\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 307010\n",
      "CONVERGED, NSTEPS: 3170 1710 2160 25803030\n",
      "CONVERGED, NSTEPS: 31701940 2000 2290\n",
      "CONVERGED, NSTEPS: 31402360 24502830\n",
      "CONVERGED, NSTEPS: 3140161020902580\n",
      "CONVERGED, NSTEPS: 2970370 157019502470 2600\n",
      "CONVERGED, NSTEPS: 297000 2680\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3210290\n",
      "CONVERGED, NSTEPS: 3210902000 2600 2670\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 275067017602430\n",
      "CONVERGED, NSTEPS: 2750 14901590 167018502700\n",
      "CONVERGED, NSTEPS: 297090 1500 27302810\n",
      "CONVERGED, NSTEPS: 29702870\n",
      "CONVERGED, NSTEPS: 27702500 2620 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 297000 2860\n",
      "CONVERGED, NSTEPS: 30300\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 31200\n",
      "CONVERGED, NSTEPS: 30200120016002790\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 27201460\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 331020 2610 2680\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 24900\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 272002012701340 15701910 199021302200\n",
      "CONVERGED, NSTEPS: 272000 2640\n",
      "CONVERGED, NSTEPS: 249020\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 270040\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810802470\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 265030\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 30201540 2230\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 27000 460990 1070 13401420 1790188020502140\n",
      "CONVERGED, NSTEPS: 27002460\n",
      "CONVERGED, NSTEPS: 26006701760 202022902360 24502530\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 263000 147016601740\n",
      "CONVERGED, NSTEPS: 2630 1420 15001580 1660 2030\n",
      "CONVERGED, NSTEPS: 29607011301220 17402530 2890\n",
      "CONVERGED, NSTEPS: 296020 1640 2200 2370\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 216050 2030\n",
      "CONVERGED, NSTEPS: 2450 194022002370\n",
      "CONVERGED, NSTEPS: 24500\n",
      "CONVERGED, NSTEPS: 2470 1220 2380\n",
      "CONVERGED, NSTEPS: 24701560 2330 2410\n",
      "CONVERGED, NSTEPS: 25600 18202100\n",
      "CONVERGED, NSTEPS: 25601670 19102280\n",
      "CONVERGED, NSTEPS: 26502030 21102190\n",
      "CONVERGED, NSTEPS: 26501950\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140015901780\n",
      "CONVERGED, NSTEPS: 2110166017502030\n",
      "CONVERGED, NSTEPS: 21100\n",
      "CONVERGED, NSTEPS: 2360290\n",
      "CONVERGED, NSTEPS: 2360501870\n",
      "CONVERGED, NSTEPS: 2410302180\n",
      "CONVERGED, NSTEPS: 24101760 2280\n",
      "CONVERGED, NSTEPS: 22000\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290501640\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 21909001990\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200801960\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2370290 19702350\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2360250155018302210\n",
      "CONVERGED, NSTEPS: 23600\n",
      "CONVERGED, NSTEPS: 2690270\n",
      "CONVERGED, NSTEPS: 2690090\n",
      "CONVERGED, NSTEPS: 24200302300\n",
      "CONVERGED, NSTEPS: 24206801840 2300\n",
      "CONVERGED, NSTEPS: 25002220\n",
      "CONVERGED, NSTEPS: 25000 2260\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 257030\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 269018002420 2500 2580\n",
      "CONVERGED, NSTEPS: 24000\n",
      "CONVERGED, NSTEPS: 24000 11902000 2080\n",
      "CONVERGED, NSTEPS: 234002270\n",
      "CONVERGED, NSTEPS: 234002020 2100\n",
      "CONVERGED, NSTEPS: 232010\n",
      "CONVERGED, NSTEPS: 2320960\n",
      "CONVERGED, NSTEPS: 2460910 1380 15501680 1760 1800 1950\n",
      "CONVERGED, NSTEPS: 2460010 1280 1530 1960\n",
      "CONVERGED, NSTEPS: 2740500 1790 221023702610\n",
      "CONVERGED, NSTEPS: 27400 1390\n",
      "CONVERGED, NSTEPS: 239030 850 1120 1200 1300\n",
      "CONVERGED, NSTEPS: 239070 1470 17001860\n",
      "CONVERGED, NSTEPS: 2580 17002300\n",
      "CONVERGED, NSTEPS: 2580 19001950 2070\n",
      "CONVERGED, NSTEPS: 265001390\n",
      "CONVERGED, NSTEPS: 265030 1430 15301650 1950 2030 2260 22702630\n",
      "CONVERGED, NSTEPS: 257060 1800 1890 2320\n",
      "CONVERGED, NSTEPS: 25701470 17602080\n",
      "CONVERGED, NSTEPS: 231010 113011501600 1960 20602250\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 263050\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 213014001640\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2290 1880 1920\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2750260 2380 2420 2750\n",
      "CONVERGED, NSTEPS: 27501880\n",
      "CONVERGED, NSTEPS: 232060\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2110902000\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 24201840 22302280\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2430 1920 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 26302240\n",
      "CONVERGED, NSTEPS: 26301570205024602610\n",
      "CONVERGED, NSTEPS: 25100 1470 1510 2070 21502320\n",
      "CONVERGED, NSTEPS: 251023102360 2410 2480\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 24500 116014001570\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400 410 11601550 2370\n",
      "CONVERGED, NSTEPS: 274020\n",
      "CONVERGED, NSTEPS: 27401810 2340\n",
      "CONVERGED, NSTEPS: 2650880 1310 1910 2020 2050\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 22301860\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360650\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2580 9202140\n",
      "CONVERGED, NSTEPS: 2580 2310 2350\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400180\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470520 17202230\n",
      "CONVERGED, NSTEPS: 2440750 20002430\n",
      "CONVERGED, NSTEPS: 24400\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 284010\n",
      "CONVERGED, NSTEPS: 2640801910\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380830 1970\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580180 1330\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 23606802290\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 243040\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 210020\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2690500\n",
      "CONVERGED, NSTEPS: 26902202540\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 261040\n",
      "CONVERGED, NSTEPS: 240090\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 22200\n",
      "CONVERGED, NSTEPS: 26200 20402380\n",
      "CONVERGED, NSTEPS: 2620960 2240\n",
      "CONVERGED, NSTEPS: 278090 1630\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 238020\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 27100502260\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 27506024802600\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2770 2210\n",
      "CONVERGED, NSTEPS: 277019802370\n",
      "CONVERGED, NSTEPS: 2350 178020202150\n",
      "CONVERGED, NSTEPS: 23500\n",
      "CONVERGED, NSTEPS: 264002220\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 26801740 2670\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2540 193023902540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 3110202320 2740\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2240190\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2670103011801470\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 26302200 2220\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540350\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290930\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 25400\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 27309302170\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 23903402370\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 264002320\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 25800\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 246002330\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2380730\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750602480\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2830202690\n",
      "CONVERGED, NSTEPS: 2830400\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 22500\n",
      "CONVERGED, NSTEPS: 25600\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 247016701890\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530270\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 22600\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540501910\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 262030\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300040\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 237018302050\n",
      "CONVERGED, NSTEPS: 242022702350\n",
      "CONVERGED, NSTEPS: 2420690\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 231050\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 26600 2520\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2130 1050\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 24000\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 25502420\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 21700\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 248080\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2450602260\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2650\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2650001850\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 27200\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 245001300\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340201870\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420902300\n",
      "CONVERGED, NSTEPS: 24900\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 27200\n",
      "CONVERGED, NSTEPS: 272002220\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490802260\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 24500\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2410940\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 26100\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 22600\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 259020\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 24000\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750440\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 243080 2410\n",
      "CONVERGED, NSTEPS: 24302501600\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 251040\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2570030\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 22901960\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 22100\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 26801770\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 236020\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260820\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 26802090\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2640940\n",
      "CONVERGED, NSTEPS: 26400\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610280\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 23700 2350\n",
      "CONVERGED, NSTEPS: 248015601900\n",
      "CONVERGED, NSTEPS: 24801330\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 25200\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260016401870\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 25600\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 262020\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 23100\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 25800\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800240\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 216010\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 23703201580\n",
      "CONVERGED, NSTEPS: 241010\n",
      "CONVERGED, NSTEPS: 24108902150\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 24801900\n",
      "CONVERGED, NSTEPS: 26900 2460 2620\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2390880118019602250\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2350270\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2250501870\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 26900\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2570210128019302440\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 241096012102010\n",
      "CONVERGED, NSTEPS: 241075015302030\n",
      "CONVERGED, NSTEPS: 20900118014401970\n",
      "CONVERGED, NSTEPS: 2090240\n",
      "CONVERGED, NSTEPS: 225040\n",
      "CONVERGED, NSTEPS: 22504020202100\n",
      "CONVERGED, NSTEPS: 21800\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2230380\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 226087019502020\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 21105402020\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 22500\n",
      "CONVERGED, NSTEPS: 189040\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 235030\n",
      "CONVERGED, NSTEPS: 2460902090\n",
      "CONVERGED, NSTEPS: 2460401950\n",
      "CONVERGED, NSTEPS: 215001370161019302150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 25102102360\n",
      "CONVERGED, NSTEPS: 2510401810\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100701520\n",
      "CONVERGED, NSTEPS: 2520601930\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 208002040\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 21509016601820\n",
      "CONVERGED, NSTEPS: 2320702260\n",
      "CONVERGED, NSTEPS: 2320402050\n",
      "CONVERGED, NSTEPS: 2440050\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 229026016402000\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 23400\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160650\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550017802020\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320019902230\n",
      "CONVERGED, NSTEPS: 21100\n",
      "CONVERGED, NSTEPS: 211001720\n",
      "CONVERGED, NSTEPS: 227001690\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210165019702050\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400030\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 25000\n",
      "CONVERGED, NSTEPS: 2500790186022702340\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120880\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2520001690\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 229090\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2420402390\n",
      "CONVERGED, NSTEPS: 242001370\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 26400\n",
      "CONVERGED, NSTEPS: 2460016601820\n",
      "CONVERGED, NSTEPS: 2460501300144015101910\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 22900\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2500\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 21600\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410160\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 23400\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 22300 2200\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2020301780\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800240\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 23400\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 25600\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 235050\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2300820\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2200790\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 272000 2570\n",
      "CONVERGED, NSTEPS: 272003017301750 1840 2310\n",
      "CONVERGED, NSTEPS: 29102270\n",
      "CONVERGED, NSTEPS: 29101024502730\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 29300\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2110000 2060\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 240002200\n",
      "CONVERGED, NSTEPS: 248001740 18201950\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 23705701620 1790 1970 2060 2130 2140 22202270\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 26200\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2380 1850 18702240 2290\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2500 23002370\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450650\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3250\n",
      "CONVERGED, NSTEPS: 3250\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 28600\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 25200\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 28100\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 241010\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 23602140\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070900\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 26800\n",
      "CONVERGED, NSTEPS: 312003030\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3300\n",
      "CONVERGED, NSTEPS: 33002970\n",
      "CONVERGED, NSTEPS: 3420\n",
      "CONVERGED, NSTEPS: 3420\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 296050\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2760730\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 288020\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 287000 2210\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3270660\n",
      "CONVERGED, NSTEPS: 3270960 3020\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 28700\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 2700560\n",
      "CONVERGED, NSTEPS: 2700023502380\n",
      "CONVERGED, NSTEPS: 31001610\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 27600\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000980\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 30200\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870730\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 267002210\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 233090\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 24700\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 258020\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230110\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 28000\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 20600\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 28300\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 264000\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 27100\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 28300\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 290080\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 296070\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2940360\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 24802450\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2430302180\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 24400\n",
      "CONVERGED, NSTEPS: 2440202050\n",
      "CONVERGED, NSTEPS: 22700\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 27800226023502560\n",
      "CONVERGED, NSTEPS: 27800\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 226050\n",
      "CONVERGED, NSTEPS: 22600\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 201001220\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 223000162016702030\n",
      "CONVERGED, NSTEPS: 223070\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 261030\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 23900\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2160530\n",
      "CONVERGED, NSTEPS: 21600\n",
      "CONVERGED, NSTEPS: 267000\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 27500158016102430\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2500650\n",
      "CONVERGED, NSTEPS: 25000\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 2840390\n",
      "CONVERGED, NSTEPS: 2940670\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 28300\n",
      "CONVERGED, NSTEPS: 2460090\n",
      "CONVERGED, NSTEPS: 246002290\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 24207809501470167018602210\n",
      "CONVERGED, NSTEPS: 2440011802280\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 25708020802450\n",
      "CONVERGED, NSTEPS: 25700147015802120\n",
      "CONVERGED, NSTEPS: 2660620\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2380020\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 254020\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 250090\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 276070\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 243090\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2400136023202370\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 244090\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230601920\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210580178018702060\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430350\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n"
     ]
    }
   ],
   "source": [
    "#Create lists of processed images WARNING: SLOW\n",
    "subpath=os.getcwd()+\"\\Sub-Data\\\\\" #set path of subimages\n",
    "filelist=os.listdir(subpath) #list subimages\n",
    "filelist=filelist[0,]\n",
    "\n",
    "normimg=np.zeros((len(filelist)),dtype=object)\n",
    "rectimg=np.zeros((len(filelist)),dtype=object) #initialize set for rectangle mask\n",
    "polyimgb=np.zeros((len(filelist)),dtype=object)\n",
    "polyimgm=np.zeros((len(filelist)),dtype=object)\n",
    "randimg=np.zeros((len(filelist)),dtype=object)\n",
    "cleanorig=np.zeros((len(filelist)),dtype=object)\n",
    "cleanrep=np.zeros((len(filelist)),dtype=object)\n",
    "\n",
    "index=0\n",
    "\n",
    "for name in filelist:\n",
    "    #read in and grayscale subimages\n",
    "    image=cv2.imread(subpath+name)\n",
    "    image=cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) #get and process image\n",
    "    mask=roiarr[np.random.randint(0,15)] #grab random mask\n",
    "    \n",
    "    normimg[index]=image\n",
    "    \n",
    "    rectimg[index]=rectArea(image)\n",
    "    \n",
    "    polyimgb[index]=unifBack(image,mask,\"black\")\n",
    "    \n",
    "    polyimgm[index]=unifBack(image,mask,\"mean\")\n",
    "    \n",
    "    randimg[index]=randBack(image,mask)\n",
    "    \n",
    "    cleanorig[index]=CLEAN(np.multiply(image,mask),mask,variant=\"standard\")\n",
    "    \n",
    "    cleanrep[index]=CLEAN(np.multiply(image,mask),mask,variant=\"replace\")\n",
    "    \n",
    "    index+=1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "4ae75f09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([36.33193863, 18.68898187, 13.11018131,  0.20920502,  1.46443515,\n",
      "       30.19525802]), 0.17651444513395315, 0.05002944656544643)\n"
     ]
    }
   ],
   "source": [
    "args=(normimg,rectimg,polyimgb,polyimgm,randimg,cleanorig,cleanrep)\n",
    "#actually computes the data\n",
    "args=(normimg,rectimg,polyimgb,polyimgm,randimg,cleanorig,cleanrep)\n",
    "print(\"chi2:\",Processor(args,'chi2'))\n",
    "print(\"SAD:\",Processor(args,'SAD'))\n",
    "print(\"SSE:\",Processor(args,'SSE'))\n",
    "print(\"STD:\",Processor(args,'STD'))\n",
    "print(\"SQR:\",Processor(args,'SQR'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e94ce3b9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}