package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
)

type Point struct {
	x, y float64
}

type Event struct {
	angle float64
	id    int
}

type EventList []Event

func (a EventList) Len() int           { return len(a) }
func (a EventList) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a EventList) Less(i, j int) bool { return a[i].angle < a[j].angle }

var events []Event
var stack []int
var inStack []int
var inStackIter int

func check(D float64, a float64, outposts []Point) bool {
	k := D * D / 4.0
	if k >= a*a {
		return true
	}

	events = events[:0]
	stack = stack[:0]
	inStackIter++

	CU := math.Sqrt(k)
	sqrt_a2_k := math.Sqrt(a*a - k)

	for i := 0; i < len(outposts); i++ {
		CV := -outposts[i].y * sqrt_a2_k
		C := outposts[i].x

		R := math.Sqrt(CU*CU + CV*CV)
		if R == 0 {
			continue
		}

		ratio := C / R
		if ratio > 1.0-1e-11 || ratio < -1.0+1e-11 {
			continue
		}

		phi := math.Atan2(CV, CU)
		delta := math.Acos(ratio)

		t1 := phi + delta
		t2 := phi - delta

		for t1 < 0 {
			t1 += 2 * math.Pi
		}
		for t1 >= 2*math.Pi {
			t1 -= 2 * math.Pi
		}
		for t2 < 0 {
			t2 += 2 * math.Pi
		}
		for t2 >= 2*math.Pi {
			t2 -= 2 * math.Pi
		}

		events = append(events, Event{t1, i}, Event{t2, i})
	}

	sort.Sort(EventList(events))

	for i := 1; i < len(events); i++ {
		if events[i].angle-events[i-1].angle < 1e-11 && events[i].id != events[i-1].id {
			return true
		}
	}
	if len(events) > 1 {
		if (2*math.Pi-events[len(events)-1].angle)+events[0].angle < 1e-11 && events[0].id != events[len(events)-1].id {
			return true
		}
	}

	for _, ev := range events {
		if inStack[ev.id] != inStackIter {
			inStack[ev.id] = inStackIter
			stack = append(stack, ev.id)
		} else {
			if len(stack) == 0 || stack[len(stack)-1] != ev.id {
				return true
			}
			stack = stack[:len(stack)-1]
		}
	}
	return false
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)
	scanner.Split(bufio.ScanWords)

	scanFloat := func() float64 {
		scanner.Scan()
		f, _ := strconv.ParseFloat(scanner.Text(), 64)
		return f
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	a := scanFloat()

	outposts := make([]Point, n)
	for i := 0; i < n; i++ {
		outposts[i].x = scanFloat()
		outposts[i].y = scanFloat()
	}

	events = make([]Event, 0, 2*n)
	stack = make([]int, 0, n)
	inStack = make([]int, n)
	inStackIter = 0

	low := 0.0
	high := 2.0 * a

	for iter := 0; iter < 80; iter++ {
		mid := (low + high) / 2.0
		if check(mid, a, outposts) {
			high = mid
		} else {
			low = mid
		}
	}

	fmt.Printf("%.9f\n", high)
}