code: func (t *Tx) Push(payloadSize uint64) []byte {
  	// Fail request if we know we will never have enough room.
  	if payloadSize > t.maxPayloadSize {
  		return nil
  	}
  
  	totalLen := payloadToSlotSize(payloadSize)
  	newNext := t.next + totalLen
  	nextWrap := (t.next & revolutionMask) | uint64(len(t.p.buffer))
  	if int64(newNext-nextWrap) >= 0 {
  		// The new buffer would overflow the pipe, so we push a wrapping
  		// slot, then try to add the actual slot to the front of the
  		// pipe.
  		newNext = (newNext & revolutionMask) + jump
  		wrappingPayloadSize := slotToPayloadSize(newNext - t.next)
  		if !t.reclaim(newNext) {
  			return nil
  		}
  
  		oldNext := t.next
  		t.next = newNext
  		if oldNext != t.tail {
  			t.p.write(oldNext, wrappingPayloadSize)
  		} else {
  			t.tailHeader = wrappingPayloadSize
  			t.Flush()
  		}
  
  		newNext += totalLen
  	}
  
  	// Check that we have enough room for the buffer.
  	if !t.reclaim(newNext) {
  		return nil
  	}
  
  	if t.next != t.tail {
  		t.p.write(t.next, payloadSize)
  	} else {
  		t.tailHeader = payloadSize
  	}
  
  	// Grab the buffer before updating t.next.
  	b := t.p.data(t.next, payloadSize)
  	t.next = newNext
  
  	return b
  }
docs: // Push reserves "payloadSize" bytes for transmission in the pipe. The caller
  // populates the returned slice with the data to be transferred and enventually
  // calls Flush() to make the data visible to the reader, or Abort() to make the
  // pipe forget all Push() calls since the last Flush().
  //
  // The returned slice is available until Flush() or Abort() is next called.
  // After that, it must not be touched.