```go
package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"sort"
)

type Interval struct {
	l, r int
	idx  int
}

type Item struct {
	r   int
	idx int
}

type MinHeap []Item

func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i].r < h[j].r }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *MinHeap) Push(x interface{}) {
	*h = append(*h, x.(Item))
}

func (h *MinHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func main() {
	r := bufio.NewReader(os.Stdin)
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()

	var n, k int
	fmt.Fscan(r, &n, &k)

	intervals := make([]Interval, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(r, &intervals[i].l, &intervals[i].r)
		intervals[i].idx = i + 1
	}

	sort.Slice(intervals, func(i, j int) bool {
		if intervals[i].l == intervals[j].l {
			return intervals[i].r < intervals[j].r
		}
		return intervals[i].l < intervals[j].l
	})

	h := &MinHeap{}
	heap.Init(h)

	bestLen := 0
	bestIdx := -1

	for i := 0; i < n; i++ {
		heap.Push(h, Item{r: intervals[i].r, idx: intervals[i].idx})
		if h.Len() > k {
			heap.Pop(h)
		}
		if h.Len() == k {
			minR := (*h)[0].r
			curLen := minR - intervals[i].l + 1
			if curLen > bestLen {
				bestLen = curLen
				bestIdx = i
			}
		}
	}

	if bestIdx == -1 {
		fmt.Fprintln(w, 0)
		for i := 1; i <= k; i++ {
			if i > 1 {
				fmt.Fprint(w, " ")
			}
			fmt.Fprint(w, i)
		}
		fmt.Fprintln(w)
		return
	}

	fmt.Fprintln(w, bestLen)
	candidates := make([]Interval, 0, bestIdx+1)
	for i := 0; i <= bestIdx; i++ {
		candidates = append(candidates, intervals[i])
	}
	sort.Slice(candidates, func(i, j int) bool {
		return candidates[i].r > candidates[j].r
	})
	for i := 0; i < k; i++ {
		if i > 0 {
			fmt.Fprint(w, " ")
		}
		fmt.Fprint(w, candidates[i].idx)
	}
	fmt.Fprintln(w)
}
```