#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <algorithm>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()

typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
    L(const P& a, const P& b){ at(0)=a; at(1)=b; }
    L(){}
};

double dot(P a, P b){
    return (conj(a)*b).X;
}
double cross(P a, P b){
    return (conj(a)*b).Y;
}
int ccw(P a, P b, P c){
    b -= a;
    c -= a;
    if(cross(b,c) > EPS) return +1; //ccw
    if(cross(b,c) < -EPS) return -1; //cw
    if(dot(b,c) < -EPS) return +2; //c-a-b
    if(abs(c)-abs(b) > EPS) return -2; //a-b-c
    return 0; //a-c-b
}

bool intersectSS(const L& a, const L& b){
    return ( ccw(a[0],a[1],b[0]) *ccw(a[0],a[1],b[1]) <= 0 ) &&
        ( ccw(b[0],b[1],a[0]) *ccw(b[0],b[1],a[1]) <= 0 );
}
double distanceLP(const L &l, const P &p) {
    return abs(cross(l[1]-l[0], p-l[0])) /abs(l[1]-l[0]);
}
double distanceSP(const L &s, const P &p) {
    if(dot(s[1]-s[0], p-s[0]) < EPS) return abs(p-s[0]);
    if(dot(s[0]-s[1], p-s[1]) < EPS) return abs(p-s[1]);
    return distanceLP(s, p);
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}

int main(){
    while(1){
        int w,n;
        cin >> w >> n;
        if(w==0) break;

        vector<VP> poly(n);
        for(int i=0; i<n; i++){
            int v;
            cin >> v;
            poly[i].resize(v);
            for(int j=0; j<v; j++){
                double x,y;
                cin >> x >> y;
                poly[i][j] = P(x, y);
            }
        }

        vector<vector<double> > adj(n+2, vector<double>(n+2, INF));
        for(int i=0; i<n; i++){
            int si = poly[i].size();
            for(int j=i+1; j<n; j++){
                int sj = poly[j].size();
                for(int pi=0; pi<si; pi++){
                    L ei(poly[i][pi], poly[i][(pi+1)%si]);
                    for(int pj=0; pj<sj; pj++){
                        L ej(poly[j][pj], poly[j][(pj+1)%sj]);
                        adj[i][j] = min(adj[i][j], distanceSS(ei, ej));
                    }
                }
                adj[j][i] = adj[i][j];
            }
        }
        L wleft(P(0,0), P(0,1));
        L wright(P(w,0), P(w,1));
        for(int i=0; i<n; i++){
            for(P pi: poly[i]){
                adj[i][n] = min(adj[i][n], distanceLP(wleft, pi));
                adj[i][n+1] = min(adj[i][n+1], distanceLP(wright, pi));
            }
            adj[n][i] = adj[i][n];
            adj[n+1][i] = adj[i][n+1];
        }
        adj[n][n+1] = adj[n+1][n] = w;

        for(int k=0; k<n+2; k++){
            for(int i=0; i<n+2; i++){
                for(int j=0; j<n+2; j++){
                    adj[i][j] = min(adj[i][j], adj[i][k] +adj[k][j]);
                }
            }
        }
        cout << fixed << setprecision(10);
        cout << adj[n][n+1] << endl;
    }
    return 0;
}


Measured memory_bytes: 3436