673 lines
14 KiB
Go
673 lines
14 KiB
Go
package xgb
|
|
|
|
/*
|
|
This file was generated by shm.xml on May 8 2012 11:03:24pm EDT.
|
|
This file is automatically generated. Edit at your peril!
|
|
*/
|
|
|
|
// Imports are not necessary for XGB because everything is
|
|
// in one package. They are still listed here for reference.
|
|
// import "xproto"
|
|
|
|
// ShmInit must be called before using the MIT-SHM extension.
|
|
func (c *Conn) ShmInit() error {
|
|
reply, err := c.QueryExtension(7, "MIT-SHM").Reply()
|
|
switch {
|
|
case err != nil:
|
|
return err
|
|
case !reply.Present:
|
|
return errorf("No extension named MIT-SHM could be found on on the server.")
|
|
}
|
|
|
|
c.extLock.Lock()
|
|
c.extensions["MIT-SHM"] = reply.MajorOpcode
|
|
for evNum, fun := range newExtEventFuncs["MIT-SHM"] {
|
|
newEventFuncs[int(reply.FirstEvent)+evNum] = fun
|
|
}
|
|
for errNum, fun := range newExtErrorFuncs["MIT-SHM"] {
|
|
newErrorFuncs[int(reply.FirstError)+errNum] = fun
|
|
}
|
|
c.extLock.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["MIT-SHM"] = make(map[int]newEventFun)
|
|
newExtErrorFuncs["MIT-SHM"] = make(map[int]newErrorFun)
|
|
}
|
|
|
|
// Skipping definition for base type 'Card8'
|
|
|
|
// Skipping definition for base type 'Int16'
|
|
|
|
// Skipping definition for base type 'Int32'
|
|
|
|
// Skipping definition for base type 'Void'
|
|
|
|
// Skipping definition for base type 'Byte'
|
|
|
|
// Skipping definition for base type 'Int8'
|
|
|
|
// Skipping definition for base type 'Card16'
|
|
|
|
// Skipping definition for base type 'Char'
|
|
|
|
// Skipping definition for base type 'Card32'
|
|
|
|
// Skipping definition for base type 'Double'
|
|
|
|
// Skipping definition for base type 'Bool'
|
|
|
|
// Skipping definition for base type 'Float'
|
|
|
|
// Skipping definition for base type 'Id'
|
|
|
|
// Skipping resource definition of 'Seg'
|
|
|
|
// Event definition ShmCompletion (0)
|
|
// Size: 32
|
|
|
|
const ShmCompletion = 0
|
|
|
|
type ShmCompletionEvent struct {
|
|
Sequence uint16
|
|
// padding: 1 bytes
|
|
Drawable Id
|
|
MinorEvent uint16
|
|
MajorEvent byte
|
|
// padding: 1 bytes
|
|
Shmseg Id
|
|
Offset uint32
|
|
}
|
|
|
|
// Event read ShmCompletion
|
|
func NewShmCompletionEvent(buf []byte) Event {
|
|
v := ShmCompletionEvent{}
|
|
b := 1 // don't read event number
|
|
|
|
b += 1 // padding
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Drawable = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.MinorEvent = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.MajorEvent = buf[b]
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
v.Shmseg = Id(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Offset = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
// Event write ShmCompletion
|
|
func (v ShmCompletionEvent) Bytes() []byte {
|
|
buf := make([]byte, 32)
|
|
b := 0
|
|
|
|
// write event number
|
|
buf[b] = 0
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
b += 2 // skip sequence number
|
|
|
|
Put32(buf[b:], uint32(v.Drawable))
|
|
b += 4
|
|
|
|
Put16(buf[b:], v.MinorEvent)
|
|
b += 2
|
|
|
|
buf[b] = v.MajorEvent
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
Put32(buf[b:], uint32(v.Shmseg))
|
|
b += 4
|
|
|
|
Put32(buf[b:], v.Offset)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
func (v ShmCompletionEvent) ImplementsEvent() {}
|
|
|
|
func (v ShmCompletionEvent) SequenceId() uint16 {
|
|
return v.Sequence
|
|
}
|
|
|
|
func (v ShmCompletionEvent) String() string {
|
|
fieldVals := make([]string, 0, 7)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("Drawable: %d", v.Drawable))
|
|
fieldVals = append(fieldVals, sprintf("MinorEvent: %d", v.MinorEvent))
|
|
fieldVals = append(fieldVals, sprintf("MajorEvent: %d", v.MajorEvent))
|
|
fieldVals = append(fieldVals, sprintf("Shmseg: %d", v.Shmseg))
|
|
fieldVals = append(fieldVals, sprintf("Offset: %d", v.Offset))
|
|
return "ShmCompletion {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtEventFuncs["MIT-SHM"][0] = NewShmCompletionEvent
|
|
}
|
|
|
|
// ErrorCopy definition ShmBadSeg (0)
|
|
|
|
const BadShmBadSeg = 0
|
|
|
|
type ShmBadSegError ValueError
|
|
|
|
func NewShmBadSegError(buf []byte) Error {
|
|
v := ShmBadSegError(NewValueError(buf).(ValueError))
|
|
v.NiceName = "ShmBadSeg"
|
|
return v
|
|
}
|
|
|
|
func (err ShmBadSegError) ImplementsError() {}
|
|
|
|
func (err ShmBadSegError) SequenceId() uint16 {
|
|
return err.Sequence
|
|
}
|
|
|
|
func (err ShmBadSegError) BadId() Id {
|
|
return Id(err.BadValue)
|
|
}
|
|
|
|
func (err ShmBadSegError) Error() string {
|
|
fieldVals := make([]string, 0, 4)
|
|
fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
|
|
fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
|
|
fieldVals = append(fieldVals, sprintf("BadValue: %d", err.BadValue))
|
|
fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
|
|
fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
|
|
return "BadShmBadSeg {" + stringsJoin(fieldVals, ", ") + "}"
|
|
}
|
|
|
|
func init() {
|
|
newExtErrorFuncs["MIT-SHM"][0] = NewShmBadSegError
|
|
}
|
|
|
|
// Request ShmQueryVersion
|
|
// size: 4
|
|
type ShmQueryVersionCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) ShmQueryVersion() ShmQueryVersionCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.shmQueryVersionRequest(), cookie)
|
|
return ShmQueryVersionCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmQueryVersionUnchecked() ShmQueryVersionCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.shmQueryVersionRequest(), cookie)
|
|
return ShmQueryVersionCookie{cookie}
|
|
}
|
|
|
|
// Request reply for ShmQueryVersion
|
|
// size: 32
|
|
type ShmQueryVersionReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
SharedPixmaps bool
|
|
MajorVersion uint16
|
|
MinorVersion uint16
|
|
Uid uint16
|
|
Gid uint16
|
|
PixmapFormat byte
|
|
// padding: 15 bytes
|
|
}
|
|
|
|
// Waits and reads reply data from request ShmQueryVersion
|
|
func (cook ShmQueryVersionCookie) Reply() (*ShmQueryVersionReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return shmQueryVersionReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for ShmQueryVersion
|
|
func shmQueryVersionReply(buf []byte) *ShmQueryVersionReply {
|
|
v := new(ShmQueryVersionReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
if buf[b] == 1 {
|
|
v.SharedPixmaps = true
|
|
} else {
|
|
v.SharedPixmaps = false
|
|
}
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.MajorVersion = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.MinorVersion = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Uid = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Gid = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.PixmapFormat = buf[b]
|
|
b += 1
|
|
|
|
b += 15 // padding
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook ShmQueryVersionCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmQueryVersion
|
|
func (c *Conn) shmQueryVersionRequest() []byte {
|
|
size := 4
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 0 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ShmAttach
|
|
// size: 16
|
|
type ShmAttachCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for ShmAttach
|
|
func (c *Conn) ShmAttach(Shmseg Id, Shmid uint32, ReadOnly bool) ShmAttachCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.shmAttachRequest(Shmseg, Shmid, ReadOnly), cookie)
|
|
return ShmAttachCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmAttachChecked(Shmseg Id, Shmid uint32, ReadOnly bool) ShmAttachCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.shmAttachRequest(Shmseg, Shmid, ReadOnly), cookie)
|
|
return ShmAttachCookie{cookie}
|
|
}
|
|
|
|
func (cook ShmAttachCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmAttach
|
|
func (c *Conn) shmAttachRequest(Shmseg Id, Shmid uint32, ReadOnly bool) []byte {
|
|
size := 16
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 1 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Shmseg))
|
|
b += 4
|
|
|
|
Put32(buf[b:], Shmid)
|
|
b += 4
|
|
|
|
if ReadOnly {
|
|
buf[b] = 1
|
|
} else {
|
|
buf[b] = 0
|
|
}
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ShmDetach
|
|
// size: 8
|
|
type ShmDetachCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for ShmDetach
|
|
func (c *Conn) ShmDetach(Shmseg Id) ShmDetachCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.shmDetachRequest(Shmseg), cookie)
|
|
return ShmDetachCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmDetachChecked(Shmseg Id) ShmDetachCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.shmDetachRequest(Shmseg), cookie)
|
|
return ShmDetachCookie{cookie}
|
|
}
|
|
|
|
func (cook ShmDetachCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmDetach
|
|
func (c *Conn) shmDetachRequest(Shmseg Id) []byte {
|
|
size := 8
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 2 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Shmseg))
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ShmPutImage
|
|
// size: 40
|
|
type ShmPutImageCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for ShmPutImage
|
|
func (c *Conn) ShmPutImage(Drawable Id, Gc Id, TotalWidth uint16, TotalHeight uint16, SrcX uint16, SrcY uint16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16, Depth byte, Format byte, SendEvent byte, Shmseg Id, Offset uint32) ShmPutImageCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.shmPutImageRequest(Drawable, Gc, TotalWidth, TotalHeight, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY, Depth, Format, SendEvent, Shmseg, Offset), cookie)
|
|
return ShmPutImageCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmPutImageChecked(Drawable Id, Gc Id, TotalWidth uint16, TotalHeight uint16, SrcX uint16, SrcY uint16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16, Depth byte, Format byte, SendEvent byte, Shmseg Id, Offset uint32) ShmPutImageCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.shmPutImageRequest(Drawable, Gc, TotalWidth, TotalHeight, SrcX, SrcY, SrcWidth, SrcHeight, DstX, DstY, Depth, Format, SendEvent, Shmseg, Offset), cookie)
|
|
return ShmPutImageCookie{cookie}
|
|
}
|
|
|
|
func (cook ShmPutImageCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmPutImage
|
|
func (c *Conn) shmPutImageRequest(Drawable Id, Gc Id, TotalWidth uint16, TotalHeight uint16, SrcX uint16, SrcY uint16, SrcWidth uint16, SrcHeight uint16, DstX int16, DstY int16, Depth byte, Format byte, SendEvent byte, Shmseg Id, Offset uint32) []byte {
|
|
size := 40
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 3 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Drawable))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(Gc))
|
|
b += 4
|
|
|
|
Put16(buf[b:], TotalWidth)
|
|
b += 2
|
|
|
|
Put16(buf[b:], TotalHeight)
|
|
b += 2
|
|
|
|
Put16(buf[b:], SrcX)
|
|
b += 2
|
|
|
|
Put16(buf[b:], SrcY)
|
|
b += 2
|
|
|
|
Put16(buf[b:], SrcWidth)
|
|
b += 2
|
|
|
|
Put16(buf[b:], SrcHeight)
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(DstX))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(DstY))
|
|
b += 2
|
|
|
|
buf[b] = Depth
|
|
b += 1
|
|
|
|
buf[b] = Format
|
|
b += 1
|
|
|
|
buf[b] = SendEvent
|
|
b += 1
|
|
|
|
b += 1 // padding
|
|
|
|
Put32(buf[b:], uint32(Shmseg))
|
|
b += 4
|
|
|
|
Put32(buf[b:], Offset)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ShmGetImage
|
|
// size: 32
|
|
type ShmGetImageCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
func (c *Conn) ShmGetImage(Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32, Format byte, Shmseg Id, Offset uint32) ShmGetImageCookie {
|
|
cookie := c.newCookie(true, true)
|
|
c.newRequest(c.shmGetImageRequest(Drawable, X, Y, Width, Height, PlaneMask, Format, Shmseg, Offset), cookie)
|
|
return ShmGetImageCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmGetImageUnchecked(Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32, Format byte, Shmseg Id, Offset uint32) ShmGetImageCookie {
|
|
cookie := c.newCookie(false, true)
|
|
c.newRequest(c.shmGetImageRequest(Drawable, X, Y, Width, Height, PlaneMask, Format, Shmseg, Offset), cookie)
|
|
return ShmGetImageCookie{cookie}
|
|
}
|
|
|
|
// Request reply for ShmGetImage
|
|
// size: 16
|
|
type ShmGetImageReply struct {
|
|
Sequence uint16
|
|
Length uint32
|
|
Depth byte
|
|
Visual Visualid
|
|
Size uint32
|
|
}
|
|
|
|
// Waits and reads reply data from request ShmGetImage
|
|
func (cook ShmGetImageCookie) Reply() (*ShmGetImageReply, error) {
|
|
buf, err := cook.reply()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if buf == nil {
|
|
return nil, nil
|
|
}
|
|
return shmGetImageReply(buf), nil
|
|
}
|
|
|
|
// Read reply into structure from buffer for ShmGetImage
|
|
func shmGetImageReply(buf []byte) *ShmGetImageReply {
|
|
v := new(ShmGetImageReply)
|
|
b := 1 // skip reply determinant
|
|
|
|
v.Depth = buf[b]
|
|
b += 1
|
|
|
|
v.Sequence = Get16(buf[b:])
|
|
b += 2
|
|
|
|
v.Length = Get32(buf[b:]) // 4-byte units
|
|
b += 4
|
|
|
|
v.Visual = Visualid(Get32(buf[b:]))
|
|
b += 4
|
|
|
|
v.Size = Get32(buf[b:])
|
|
b += 4
|
|
|
|
return v
|
|
}
|
|
|
|
func (cook ShmGetImageCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmGetImage
|
|
func (c *Conn) shmGetImageRequest(Drawable Id, X int16, Y int16, Width uint16, Height uint16, PlaneMask uint32, Format byte, Shmseg Id, Offset uint32) []byte {
|
|
size := 32
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 4 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Drawable))
|
|
b += 4
|
|
|
|
Put16(buf[b:], uint16(X))
|
|
b += 2
|
|
|
|
Put16(buf[b:], uint16(Y))
|
|
b += 2
|
|
|
|
Put16(buf[b:], Width)
|
|
b += 2
|
|
|
|
Put16(buf[b:], Height)
|
|
b += 2
|
|
|
|
Put32(buf[b:], PlaneMask)
|
|
b += 4
|
|
|
|
buf[b] = Format
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
Put32(buf[b:], uint32(Shmseg))
|
|
b += 4
|
|
|
|
Put32(buf[b:], Offset)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|
|
|
|
// Request ShmCreatePixmap
|
|
// size: 28
|
|
type ShmCreatePixmapCookie struct {
|
|
*cookie
|
|
}
|
|
|
|
// Write request to wire for ShmCreatePixmap
|
|
func (c *Conn) ShmCreatePixmap(Pid Id, Drawable Id, Width uint16, Height uint16, Depth byte, Shmseg Id, Offset uint32) ShmCreatePixmapCookie {
|
|
cookie := c.newCookie(false, false)
|
|
c.newRequest(c.shmCreatePixmapRequest(Pid, Drawable, Width, Height, Depth, Shmseg, Offset), cookie)
|
|
return ShmCreatePixmapCookie{cookie}
|
|
}
|
|
|
|
func (c *Conn) ShmCreatePixmapChecked(Pid Id, Drawable Id, Width uint16, Height uint16, Depth byte, Shmseg Id, Offset uint32) ShmCreatePixmapCookie {
|
|
cookie := c.newCookie(true, false)
|
|
c.newRequest(c.shmCreatePixmapRequest(Pid, Drawable, Width, Height, Depth, Shmseg, Offset), cookie)
|
|
return ShmCreatePixmapCookie{cookie}
|
|
}
|
|
|
|
func (cook ShmCreatePixmapCookie) Check() error {
|
|
return cook.check()
|
|
}
|
|
|
|
// Write request to wire for ShmCreatePixmap
|
|
func (c *Conn) shmCreatePixmapRequest(Pid Id, Drawable Id, Width uint16, Height uint16, Depth byte, Shmseg Id, Offset uint32) []byte {
|
|
size := 28
|
|
b := 0
|
|
buf := make([]byte, size)
|
|
|
|
buf[b] = c.extensions["MIT-SHM"]
|
|
b += 1
|
|
|
|
buf[b] = 5 // request opcode
|
|
b += 1
|
|
|
|
Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
|
|
b += 2
|
|
|
|
Put32(buf[b:], uint32(Pid))
|
|
b += 4
|
|
|
|
Put32(buf[b:], uint32(Drawable))
|
|
b += 4
|
|
|
|
Put16(buf[b:], Width)
|
|
b += 2
|
|
|
|
Put16(buf[b:], Height)
|
|
b += 2
|
|
|
|
buf[b] = Depth
|
|
b += 1
|
|
|
|
b += 3 // padding
|
|
|
|
Put32(buf[b:], uint32(Shmseg))
|
|
b += 4
|
|
|
|
Put32(buf[b:], Offset)
|
|
b += 4
|
|
|
|
return buf
|
|
}
|