See the License for the specific language governing permissions and
limitations under the License.
*/

package tail

import (
	"io"
	"os"
)

const (
	// blockSize is the block size used in tail.
	blockSize = 1024
)

// ReadAtMost reads at most max bytes from the end of the file identified by path or

			// average anyway.)
			// The root.dequeue above changed the head and tail acquiretime
			// to the current time, so the next unlock will not re-count this contention.
			dt0 := t0 - acquiretime
			dt := dt0
			if s.waiters != 0 {
				dtail := t0 - tailtime
				dt += (dtail + dt0) / 2 * int64(s.waiters)
			}
			mutexevent(dt, 3+skipframes)
		}
		if s.ticket != 0 {

                for (int i = 0; i < this.tabs.size(); i++) {
                    TabDefinition tab = this.tabs.get(i);
                    String tabId = "tab" + i;
                    htmlWriterWriter.startElement("li");
                        htmlWriterWriter.startElement("a").attribute("href", "#" + tabId).characters(tab.title).endElement();
                    htmlWriterWriter.endElement();
                }
            htmlWriterWriter.endElement();

type dequeueNil *struct{}

func (d *poolDequeue) unpack(ptrs uint64) (head, tail uint32) {
	const mask = 1<<dequeueBits - 1
	head = uint32((ptrs >> dequeueBits) & mask)
	tail = uint32(ptrs & mask)
	return
}

func (d *poolDequeue) pack(head, tail uint32) uint64 {
	const mask = 1<<dequeueBits - 1
	return (uint64(head) << dequeueBits) |
		uint64(tail&mask)
}

// pushHead adds val at the head of the queue. It returns false if the

	w.save(a)
	w.save(b)
	w.save(c)

	var tail []byte
	tail = append(tail, a...)
	tail = append(tail, b...)
	tail = append(tail, c...)

	if len(tail) > size {
		tail = tail[len(tail)-size:]
	}

	if w.len() != uint32(len(tail)) {
		t.Errorf("wrong data length: got: %d, want: %d", w.len(), len(tail))
	}

	var from, to uint32
	for from = 0; from <= uint32(len(tail)); from++ {

    def "empty input produces specific output"() {
        expect:
        DaemonLogFileUtils.tail(log(""), 10) == "<<empty>>"
    }

    def "returns last line if the limit is one"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3""")

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "input-ending eoln is ignored"() {
        given:

		}
		b.current = body
		b.targets = &targets{
			tail:         b.targets,
			_break:       done,
			_fallthrough: fallthru,
		}
		b.stmtList(cc.Body)
		b.targets = b.targets.tail
		b.jump(done)
		b.current = nextCond
	}
	if defaultBlock != nil {
		b.jump(defaultBlock)
		b.current = defaultBlock
		b.targets = &targets{
			tail:         b.targets,
			_break:       done,

        private final T head;
        private final PersistentList<T> tail;

        public Cons(T head, PersistentList<T> tail) {
            this.head = head;
            this.tail = tail;
        }

        @Override
        public void forEach(Consumer<? super T> consumer) {
            consumer.accept(head);
            tail.forEach(consumer);
        }

        @Override

func (b *spanSet) reset() {
	head, tail := b.index.load().split()
	if head < tail {
		print("head = ", head, ", tail = ", tail, "\n")
		throw("attempt to clear non-empty span set")
	}
	top := head / spanSetBlockEntries
	if uintptr(top) < b.spineLen.Load() {
		// If the head catches up to the tail and the set is empty,
		// we may not clean up the block containing the head and tail

        try {
            String tail = DaemonLogFileUtils.tail(getDaemonLog(), TAIL_SIZE);
            return formatTail(tail);
        } catch (IOException e) {
            return "Unable to read from the daemon log file: " + getDaemonLog().getAbsolutePath() + ", because of: " + e.getCause();
        }
    }

    private String formatTail(String tail) {