Total Comparison Brodatz.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "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": 5,
   "id": "01e2cbe5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CLEAN(image,mask,gain=0.5,maxsteps=15000,limit=2,convcheck=10,variant=\"original\"):\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",
    "    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",
    "        # if the original image should be part of the output, this optimizes the matching of the two images\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": 6,
   "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",
    "    #sets variables\n",
    "    width,height=image.shape\n",
    "    delta=fft2(image)\n",
    "    N2=width*height\n",
    "    \n",
    "    #Fourier transforms the inputs\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",
    "    #performs the binning with log10 spacing\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",
    "    \n",
    "    #averages over the bins\n",
    "    Pkj = Pkj / nj / N2\n",
    "    lkaj = lkaj / nj \n",
    "    kaj = 10.**lkaj\n",
    "    return(Pkj,kaj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "    \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": 8,
   "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": 9,
   "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": 10,
   "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": 12,
   "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": 13,
   "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": 14,
   "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": 15,
   "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",
    "    \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==\"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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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": 48,
   "id": "20623824",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2800\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2100\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2100\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visual Test\n",
    "subpath=os.getcwd()+\"\\Sub-Brodatz\\\\\" #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",
    "imglist=[]\n",
    "\n",
    "plt.imshow(image,cmap='gray');plt.show()\n",
    "imglist.append(image)\n",
    "\n",
    "test=rectArea(image)\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)\n",
    "\n",
    "test=unifBack(image,mask,\"black\")\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)\n",
    "\n",
    "test=unifBack(image,mask,\"mean\")\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)\n",
    "\n",
    "test=randBack(image,mask)\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)\n",
    "\n",
    "cimg=np.multiply(image,mask)\n",
    "test=CLEAN(cimg,mask,variant=\"standard\")\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)\n",
    "\n",
    "test=CLEAN(cimg,mask,variant=\"replace\")\n",
    "plt.imshow(test,cmap='gray');plt.show()\n",
    "imglist.append(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f43cbaa5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 29900\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 332002290 31003250\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2900510\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1820\n",
      "CONVERGED, NSTEPS: 1820\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 22600 2230\n",
      "CONVERGED, NSTEPS: 20000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 24400\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140018201920\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930430 1470\n",
      "CONVERGED, NSTEPS: 19400 1630 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270970\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 28502080\n",
      "CONVERGED, NSTEPS: 2850002420 24702610\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 274090\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 313013401410 1670 22002430\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 27002160 2190 2510 2660\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 28200\n",
      "CONVERGED, NSTEPS: 26600\n",
      "CONVERGED, NSTEPS: 266080 2190 2200\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 29601800\n",
      "CONVERGED, NSTEPS: 29600\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 246000\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 27900\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2530960 2140 2300\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 24204902360\n",
      "CONVERGED, NSTEPS: 23901340\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2520 2230\n",
      "CONVERGED, NSTEPS: 2520930214022602340\n",
      "CONVERGED, NSTEPS: 24900 2090\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 23900 2250\n",
      "CONVERGED, NSTEPS: 2390540\n",
      "CONVERGED, NSTEPS: 244001930\n",
      "CONVERGED, NSTEPS: 24402260\n",
      "CONVERGED, NSTEPS: 2490 1610 2260\n",
      "CONVERGED, NSTEPS: 24905201570\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540920\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 27902390\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 26400\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 29700\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 31200\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 313010\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2840580\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 293050\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2700\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 317040\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 26202450\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 242002050\n",
      "CONVERGED, NSTEPS: 281002040207021902780\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 3420\n",
      "CONVERGED, NSTEPS: 3420\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 24108302100\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2720\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 32000\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 27800\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 26500\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\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: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 28100\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 294020\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 269002500\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 294016502700\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 24400\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 28800\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 288018902750\n",
      "CONVERGED, NSTEPS: 2700630\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 271090\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920660\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 32100\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 27802060\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 24800\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 27002680\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2710002450\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 23600\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 24801690\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2510510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 26202330\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290260\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 209050\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 28700\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 25600\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 253020\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 26700\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 263040\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 26200\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 25300\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 252040\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 320010 3000\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140020502360\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 21900\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2160080\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 23700\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 263090\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 1730\n",
      "CONVERGED, NSTEPS: 1730\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1820\n",
      "CONVERGED, NSTEPS: 1820\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 1730\n",
      "CONVERGED, NSTEPS: 1730\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 1600\n",
      "CONVERGED, NSTEPS: 1600\n",
      "CONVERGED, NSTEPS: 1640\n",
      "CONVERGED, NSTEPS: 1640\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 1680\n",
      "CONVERGED, NSTEPS: 1680\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1800\n",
      "CONVERGED, NSTEPS: 1800\n",
      "CONVERGED, NSTEPS: 1510\n",
      "CONVERGED, NSTEPS: 1510\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1640\n",
      "CONVERGED, NSTEPS: 1640\n",
      "CONVERGED, NSTEPS: 1630\n",
      "CONVERGED, NSTEPS: 1630\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1610\n",
      "CONVERGED, NSTEPS: 1610\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 207080\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1920\n",
      "CONVERGED, NSTEPS: 1920\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 218001750\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 1720\n",
      "CONVERGED, NSTEPS: 1720\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 1750\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 1830\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 1770\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 23100\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 213090\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210702130\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 2240\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 26800\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 3150023202650\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 27900\n",
      "CONVERGED, NSTEPS: 2790300\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 308024802990\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 274002530\n",
      "CONVERGED, NSTEPS: 287090129019802160\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 284002400\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 301051020202350\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 27600\n",
      "CONVERGED, NSTEPS: 27600\n",
      "CONVERGED, NSTEPS: 313010\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 259060\n",
      "CONVERGED, NSTEPS: 2590002450\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 246010\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 29700\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 29700\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3360\n",
      "CONVERGED, NSTEPS: 3360\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090090\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3460\n",
      "CONVERGED, NSTEPS: 3460370\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 3440\n",
      "CONVERGED, NSTEPS: 3440\n",
      "CONVERGED, NSTEPS: 3200001860\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 310020202028802960\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 3320\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 302030\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 316080\n",
      "CONVERGED, NSTEPS: 3160801340\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3380\n",
      "CONVERGED, NSTEPS: 3380\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 289002550\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 310070\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 301010\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 29500\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 3270\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 29200\n",
      "CONVERGED, NSTEPS: 29200\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 301050199021402210274028302940\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 32000\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970900\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750002750\n",
      "CONVERGED, NSTEPS: 27002420\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 242040\n",
      "CONVERGED, NSTEPS: 2420890\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 26300\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 255001950\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 3240\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 3280\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450760\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530530\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 26900\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760620\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 25107024702510\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 254080\n",
      "CONVERGED, NSTEPS: 2610570\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 228070\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2100\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 29300\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 307070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 3400250 2300\n",
      "CONVERGED, NSTEPS: 3400\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 3290\n",
      "CONVERGED, NSTEPS: 3290\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850 2640\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2500\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 31200\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 30300\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 299001930\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 255050\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 28400\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2280\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 208080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960440\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 25500\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 3370\n",
      "CONVERGED, NSTEPS: 3370\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3360\n",
      "CONVERGED, NSTEPS: 33600\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 3330\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2570202480\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540200238024202480\n",
      "CONVERGED, NSTEPS: 27001016401930\n",
      "CONVERGED, NSTEPS: 270056016102500\n",
      "CONVERGED, NSTEPS: 240001880\n",
      "CONVERGED, NSTEPS: 240080\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 26100\n",
      "CONVERGED, NSTEPS: 2680102130\n",
      "CONVERGED, NSTEPS: 268001350150017101820193022902430\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 257060096019102110\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 23704011801210180019902250\n",
      "CONVERGED, NSTEPS: 237001530\n",
      "CONVERGED, NSTEPS: 25501000 16402300\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 25600\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2450\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130090\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 29000\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 3340\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 3170\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 3110\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 276020\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3030\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 3310\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3150\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 2830160\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 281080\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3190\n",
      "CONVERGED, NSTEPS: 3470\n",
      "CONVERGED, NSTEPS: 3470\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3220\n",
      "CONVERGED, NSTEPS: 3220\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3300\n",
      "CONVERGED, NSTEPS: 3300\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3230\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 3060\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 271002420\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2840\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 275040\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2940\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2890\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 2960\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3050\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3300\n",
      "CONVERGED, NSTEPS: 3300\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3180\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 3390\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3080\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 3090\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3160\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3020\n",
      "CONVERGED, NSTEPS: 3370\n",
      "CONVERGED, NSTEPS: 3370\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3120\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 3210\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1900\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 21502070\n",
      "CONVERGED, NSTEPS: 2150\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2220\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 1970\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2300\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2010\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 1790\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1700\n",
      "CONVERGED, NSTEPS: 1700\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2120\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 1850\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 263002460\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 2670\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 1870\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930040\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 3200\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2950\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 268030\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2200\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 3010\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 1980\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2140\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2070\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2130\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 2250\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1910\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 1860\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 1780\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2030\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2170\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 2800\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1990\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1920\n",
      "CONVERGED, NSTEPS: 1920\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2690\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2650\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 25601750\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 3140\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2590\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2990\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2330\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2390\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2340\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2380\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2310\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2860\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2370\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2090\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2060\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2460\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2540\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2360\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 2600\n",
      "CONVERGED, NSTEPS: 258030\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2410\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2210\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2700\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2420\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2180\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2270\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2260\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2160\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 2230\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2110\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2080\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2050\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1880\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 1960\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 2000\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 1840\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 2020\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1940\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 1950\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2190\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2040\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 2430\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 1810\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 2290\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1890\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1760\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 1930\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2440\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2720\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 2520\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 3000\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 3040\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2630\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2710\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2680\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2320\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 2480\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 3130\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 3040\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2810\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2570\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2640\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2560\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 3070\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2980\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2820\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2830\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2880\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2930\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 2620\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 3100\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2970\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2870\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2660\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2780\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2730\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2610\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 2490\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 3260\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2790\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2910\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2750\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2920\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2470\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2580\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2350\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2900\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2770\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2510\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2760\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2550\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2740\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2850\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2400\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2530\n",
      "CONVERGED, NSTEPS: 2500\n",
      "CONVERGED, NSTEPS: 2500\n"
     ]
    }
   ],
   "source": [
    "#Create lists of processed images WARNING: SLOW\n",
    "import pandas as pd\n",
    "subpath=os.getcwd()+\"\\Sub-Brodatz\\\\\" #set path of subimages\n",
    "filelist=os.listdir(subpath) #list subimages\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": 31,
   "id": "4ae75f09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([82.78571429,  7.64285714,  1.96428571,  2.96428571,  2.5       ,\n",
      "        2.14285714]), 0.09698340874811462, 0.12226266983082902)\n"
     ]
    }
   ],
   "source": [
    "#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'))"
   ]
  }
 ],
 "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
}