#include <iostream>
#include <cmath>
#include <fstream>
#include <float.h>
#include <stdio.h>

using namespace std;

#define in cin
//ifstream in("3112.txt");

struct Segmento
{
	double x1, x2, y;
    bool operator < (const Segmento &s)
    {
        return x1 < s.x1;
    }
};

template <class T>
void quicksort(T a[], int izq, int der) {
    int i = izq, j = der;
    T med = a[(izq+der)/2], temp;

    //  buscar pivote, toma el elemento del medio y pasa a todos los mayores a su derecha y los menores a su izquierda
    while (i <= j) {
        while (a[i] < med) i++; // ord ascend       while (med < a[i]) i++; ord descend
        while (med < a[j]) j--; // ord ascend       while (a[j] < med) j--; ord descend
        if (i <= j) {
            temp = a[i]; a[i] = a[j]; a[j] = temp;
            i++; j--;
        }
    }

    if (izq < j) quicksort(a, izq, j);
    if (i < der) quicksort(a, i, der);
}

double maxi(double a, double b)
{
	return (a > b) ? a : b;
}

double pendiente(double x1, double y1, double x2, double y2)
{
	return (x1 == x2) ? DBL_MAX : (y2 - y1) / (x2 - x1);
}

double ordenada(double x, double y, double pend)
{
	return y - pend * x;
}

void llevarALinea(Segmento segs[], int n, double ly, double hx1, double hx2, double hy)
{
	double pend = pendiente(hx2, hy, segs[n].x1, segs[n].y);
	if (pend - DBL_MAX != 0)
		segs[n].x1 = (ly - ordenada(segs[n].x1, segs[n].y, pend)) / pend;

	pend = pendiente(hx1, hy, segs[n].x2, segs[n].y);
	if (pend - DBL_MAX != 0)
		segs[n].x2 = (ly - ordenada(segs[n].x2, segs[n].y, pend)) / pend;

    segs[n].y = ly;
}

int combinarSegmentos(Segmento segs[], int obs)
{
    int n = 0;

    for (int i = 0; i < obs; i++)
    {
        if (segs[n].x2 < segs[i].x1)
        {
            n++;
            segs[n].x1 = segs[i].x1;
            segs[n].x2 = segs[i].x2;
        }
        else
            if (segs[n].x2 < segs[i].x2)
				segs[n].x2 = segs[i].x2;
    }

    return n; // posición de último segmento
}

int main()
{
	double hx1, hx2, hy;
	double lx1, lx2, ly;
	int obs;

	while (in >> hx1 >> hx2 >> hy && (hx1 != 0 && hx2 != 0 && hy != 0))
	{
		in >> lx1 >> lx2 >> ly;
		in >> obs;

		Segmento segs[obs+2];

        int n = 0;
        for (int i = 0; i < obs; i++)
        {
			in >> segs[n].x1;
			in >> segs[n].x2;
			in >> segs[n].y;

            if (segs[n].y > ly && segs[n].y < hy)
            {
                llevarALinea(segs, n, ly, hx1, hx2, hy);    // mueve el obstáculo hacia la línea, estirándolo
                if (segs[n].x2 >= lx1 && segs[n].x1 <= lx2)
                    n++;    // si no se va de los límites de la línea, aumento
            }
		}

        segs[n].x1 = lx1;   // límites de la línea
        segs[n++].x2 = lx1;
        segs[n].x1 = lx2;
        segs[n++].x2 = lx2;

		quicksort(segs, 0, n-1);    // los ordeno con la relaciňn x1i < x1j

        n = combinarSegmentos(segs, n);

		double maximo = 0;

        for (int i = 0; i < n; i++)
            maximo = maxi(maximo, segs[i+1].x1 - segs[i].x2);

        if (maximo == 0)
            cout << "No View" << endl;
        else
            printf("%.2f\n", maximo);
	}

	return 0;
}