2012-12-13 15:05:22 -06:00
|
|
|
|
// xfail-fast
|
|
|
|
|
|
2012-12-10 19:32:48 -06:00
|
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
|
//
|
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
2012-09-19 00:45:24 -05:00
|
|
|
|
// tjc: I don't know why
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub mod pipes {
|
2013-01-08 00:13:34 -06:00
|
|
|
|
use core::cast::{forget, transmute};
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2013-01-26 00:46:32 -06:00
|
|
|
|
pub struct Stuff<T> {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
state: state,
|
|
|
|
|
blocked_task: Option<task::Task>,
|
|
|
|
|
payload: Option<T>
|
2013-01-26 00:46:32 -06:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-14 23:17:26 -06:00
|
|
|
|
#[deriving_eq]
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub enum state {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
empty,
|
|
|
|
|
full,
|
|
|
|
|
blocked,
|
|
|
|
|
terminated
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-28 12:46:43 -06:00
|
|
|
|
pub type packet<T> = {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
state: state,
|
|
|
|
|
blocked_task: Option<task::Task>,
|
|
|
|
|
payload: Option<T>
|
2012-06-26 00:11:19 -05:00
|
|
|
|
};
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub fn packet<T:Owned>() -> *packet<T> {
|
2013-01-23 13:43:58 -06:00
|
|
|
|
unsafe {
|
2013-01-26 00:46:32 -06:00
|
|
|
|
let p: *packet<T> = cast::transmute(~Stuff{
|
2013-02-22 18:08:16 -06:00
|
|
|
|
state: empty,
|
|
|
|
|
blocked_task: None::<task::Task>,
|
|
|
|
|
payload: None::<T>
|
2013-01-23 13:43:58 -06:00
|
|
|
|
});
|
|
|
|
|
p
|
|
|
|
|
}
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[abi = "rust-intrinsic"]
|
|
|
|
|
mod rusti {
|
2013-02-11 21:26:38 -06:00
|
|
|
|
pub fn atomic_xchg(_dst: &mut int, _src: int) -> int { fail!(); }
|
|
|
|
|
pub fn atomic_xchg_acq(_dst: &mut int, _src: int) -> int { fail!(); }
|
|
|
|
|
pub fn atomic_xchg_rel(_dst: &mut int, _src: int) -> int { fail!(); }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-01-07 20:54:28 -06:00
|
|
|
|
// We should consider moving this to ::core::unsafe, although I
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// suspect graydon would want us to use void pointers instead.
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub unsafe fn uniquify<T>(+x: *T) -> ~T {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
unsafe { cast::transmute(x) }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn swap_state_acq(+dst: &mut state, src: state) -> state {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
unsafe {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
transmute(rusti::atomic_xchg_acq(transmute(dst), src as int))
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn swap_state_rel(+dst: &mut state, src: state) -> state {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
unsafe {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
transmute(rusti::atomic_xchg_rel(transmute(dst), src as int))
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-22 18:08:16 -06:00
|
|
|
|
pub fn send<T:Owned>(mut p: send_packet<T>, -payload: T) {
|
|
|
|
|
let mut p = p.unwrap();
|
|
|
|
|
let mut p = unsafe { uniquify(p) };
|
2012-08-27 18:26:35 -05:00
|
|
|
|
assert (*p).payload.is_none();
|
2013-02-15 04:44:18 -06:00
|
|
|
|
(*p).payload = Some(payload);
|
2012-08-23 16:19:35 -05:00
|
|
|
|
let old_state = swap_state_rel(&mut (*p).state, full);
|
2012-08-06 14:34:08 -05:00
|
|
|
|
match old_state {
|
2012-08-03 21:59:04 -05:00
|
|
|
|
empty => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// Yay, fastpath.
|
2012-06-25 14:21:01 -05:00
|
|
|
|
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// The receiver will eventually clean this up.
|
2013-02-15 04:44:18 -06:00
|
|
|
|
unsafe { forget(p); }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2013-02-11 21:26:38 -06:00
|
|
|
|
full => { fail!(~"duplicate send") }
|
2012-08-03 21:59:04 -05:00
|
|
|
|
blocked => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
|
|
|
|
// The receiver will eventually clean this up.
|
2013-02-15 04:44:18 -06:00
|
|
|
|
unsafe { forget(p); }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
terminated => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// The receiver will never receive this. Rely on drop_glue
|
|
|
|
|
// to clean everything up.
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-22 18:08:16 -06:00
|
|
|
|
pub fn recv<T:Owned>(mut p: recv_packet<T>) -> Option<T> {
|
|
|
|
|
let mut p = p.unwrap();
|
|
|
|
|
let mut p = unsafe { uniquify(p) };
|
2012-06-26 00:11:19 -05:00
|
|
|
|
loop {
|
2012-08-23 16:19:35 -05:00
|
|
|
|
let old_state = swap_state_acq(&mut (*p).state,
|
2012-06-26 00:11:19 -05:00
|
|
|
|
blocked);
|
2012-08-06 14:34:08 -05:00
|
|
|
|
match old_state {
|
2012-08-03 21:59:04 -05:00
|
|
|
|
empty | blocked => { task::yield(); }
|
|
|
|
|
full => {
|
2012-08-20 14:23:37 -05:00
|
|
|
|
let mut payload = None;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
payload <-> (*p).payload;
|
2013-02-15 04:44:18 -06:00
|
|
|
|
return Some(option::unwrap(payload))
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
terminated => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
assert old_state == terminated;
|
2012-08-20 14:23:37 -05:00
|
|
|
|
return None;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-22 18:08:16 -06:00
|
|
|
|
pub fn sender_terminate<T:Owned>(mut p: *packet<T>) {
|
|
|
|
|
let mut p = unsafe { uniquify(p) };
|
2012-08-23 16:19:35 -05:00
|
|
|
|
match swap_state_rel(&mut (*p).state, terminated) {
|
2012-08-03 21:59:04 -05:00
|
|
|
|
empty | blocked => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// The receiver will eventually clean up.
|
2013-02-15 04:44:18 -06:00
|
|
|
|
unsafe { forget(p) }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
full => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// This is impossible
|
2013-02-11 21:26:38 -06:00
|
|
|
|
fail!(~"you dun goofed")
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
terminated => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// I have to clean up, use drop_glue
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-22 18:08:16 -06:00
|
|
|
|
pub fn receiver_terminate<T:Owned>(mut p: *packet<T>) {
|
|
|
|
|
let mut p = unsafe { uniquify(p) };
|
2012-08-23 16:19:35 -05:00
|
|
|
|
match swap_state_rel(&mut (*p).state, terminated) {
|
2012-08-03 21:59:04 -05:00
|
|
|
|
empty => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// the sender will clean up
|
2013-02-15 04:44:18 -06:00
|
|
|
|
unsafe { forget(p) }
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
blocked => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// this shouldn't happen.
|
2013-02-11 21:26:38 -06:00
|
|
|
|
fail!(~"terminating a blocked packet")
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-08-03 21:59:04 -05:00
|
|
|
|
terminated | full => {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
// I have to clean up, use drop_glue
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-28 12:46:43 -06:00
|
|
|
|
pub struct send_packet<T> {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
p: Option<*packet<T>>,
|
2012-11-14 00:22:37 -06:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub impl<T:Owned> Drop for send_packet<T> {
|
2012-11-28 17:42:16 -06:00
|
|
|
|
fn finalize(&self) {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
unsafe {
|
|
|
|
|
if self.p != None {
|
|
|
|
|
let mut p = None;
|
|
|
|
|
let self_p: &mut Option<*packet<T>> =
|
|
|
|
|
cast::transmute(&self.p);
|
|
|
|
|
p <-> *self_p;
|
|
|
|
|
sender_terminate(option::unwrap(p))
|
|
|
|
|
}
|
2012-06-25 14:21:01 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2012-09-07 21:04:40 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub impl<T:Owned> send_packet<T> {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
fn unwrap(&mut self) -> *packet<T> {
|
2012-08-20 14:23:37 -05:00
|
|
|
|
let mut p = None;
|
2012-06-25 14:21:01 -05:00
|
|
|
|
p <-> self.p;
|
2013-02-15 04:44:18 -06:00
|
|
|
|
option::unwrap(p)
|
2012-06-25 14:21:01 -05:00
|
|
|
|
}
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub fn send_packet<T:Owned>(p: *packet<T>) -> send_packet<T> {
|
2012-09-05 17:58:43 -05:00
|
|
|
|
send_packet {
|
|
|
|
|
p: Some(p)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-28 12:46:43 -06:00
|
|
|
|
pub struct recv_packet<T> {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
p: Option<*packet<T>>,
|
2012-11-14 00:22:37 -06:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub impl<T:Owned> Drop for recv_packet<T> {
|
2012-11-28 17:42:16 -06:00
|
|
|
|
fn finalize(&self) {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
unsafe {
|
|
|
|
|
if self.p != None {
|
|
|
|
|
let mut p = None;
|
|
|
|
|
let self_p: &mut Option<*packet<T>> =
|
|
|
|
|
cast::transmute(&self.p);
|
|
|
|
|
p <-> *self_p;
|
|
|
|
|
receiver_terminate(option::unwrap(p))
|
|
|
|
|
}
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2012-09-07 21:04:40 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub impl<T:Owned> recv_packet<T> {
|
2013-02-22 18:08:16 -06:00
|
|
|
|
fn unwrap(&mut self) -> *packet<T> {
|
2012-08-20 14:23:37 -05:00
|
|
|
|
let mut p = None;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
p <-> self.p;
|
2013-02-15 04:44:18 -06:00
|
|
|
|
option::unwrap(p)
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub fn recv_packet<T:Owned>(p: *packet<T>) -> recv_packet<T> {
|
2012-09-05 17:58:43 -05:00
|
|
|
|
recv_packet {
|
|
|
|
|
p: Some(p)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 19:07:17 -06:00
|
|
|
|
pub fn entangle<T:Owned>() -> (send_packet<T>, recv_packet<T>) {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
let p = packet();
|
|
|
|
|
(send_packet(p), recv_packet(p))
|
|
|
|
|
}
|
2012-06-25 14:21:01 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub mod pingpong {
|
2013-01-08 00:13:34 -06:00
|
|
|
|
use core::cast;
|
|
|
|
|
use core::ptr;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub enum ping = ::pipes::send_packet<pong>;
|
|
|
|
|
pub enum pong = ::pipes::send_packet<ping>;
|
|
|
|
|
|
2013-01-23 13:43:58 -06:00
|
|
|
|
pub fn liberate_ping(-p: ping) -> ::pipes::send_packet<pong> {
|
|
|
|
|
unsafe {
|
|
|
|
|
let addr : *::pipes::send_packet<pong> = match &p {
|
|
|
|
|
&ping(ref x) => { cast::transmute(ptr::addr_of(x)) }
|
|
|
|
|
};
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let liberated_value = *addr;
|
|
|
|
|
cast::forget(p);
|
|
|
|
|
liberated_value
|
2013-01-23 13:43:58 -06:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub fn liberate_pong(-p: pong) -> ::pipes::send_packet<ping> {
|
|
|
|
|
unsafe {
|
|
|
|
|
let addr : *::pipes::send_packet<ping> = match &p {
|
|
|
|
|
&pong(ref x) => { cast::transmute(ptr::addr_of(x)) }
|
|
|
|
|
};
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let liberated_value = *addr;
|
|
|
|
|
cast::forget(p);
|
|
|
|
|
liberated_value
|
2013-01-23 13:43:58 -06:00
|
|
|
|
}
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn init() -> (client::ping, server::ping) {
|
|
|
|
|
::pipes::entangle()
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub mod client {
|
2013-01-08 00:13:34 -06:00
|
|
|
|
use core::option;
|
2012-12-28 19:17:05 -06:00
|
|
|
|
use pingpong;
|
|
|
|
|
|
|
|
|
|
pub type ping = ::pipes::send_packet<pingpong::ping>;
|
|
|
|
|
pub type pong = ::pipes::recv_packet<pingpong::pong>;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn do_ping(-c: ping) -> pong {
|
|
|
|
|
let (sp, rp) = ::pipes::entangle();
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2013-02-15 04:44:18 -06:00
|
|
|
|
::pipes::send(c, pingpong::ping(sp));
|
|
|
|
|
rp
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn do_pong(-c: pong) -> (ping, ()) {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let packet = ::pipes::recv(c);
|
2012-08-27 18:26:35 -05:00
|
|
|
|
if packet.is_none() {
|
2013-02-11 21:26:38 -06:00
|
|
|
|
fail!(~"sender closed the connection")
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2013-02-15 04:44:18 -06:00
|
|
|
|
(pingpong::liberate_pong(option::unwrap(packet)), ())
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub mod server {
|
|
|
|
|
use pingpong;
|
|
|
|
|
|
|
|
|
|
pub type ping = ::pipes::recv_packet<pingpong::ping>;
|
|
|
|
|
pub type pong = ::pipes::send_packet<pingpong::pong>;
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn do_ping(-c: ping) -> (pong, ()) {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let packet = ::pipes::recv(c);
|
2012-08-27 18:26:35 -05:00
|
|
|
|
if packet.is_none() {
|
2013-02-11 21:26:38 -06:00
|
|
|
|
fail!(~"sender closed the connection")
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2013-02-15 04:44:18 -06:00
|
|
|
|
(pingpong::liberate_ping(option::unwrap(packet)), ())
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-12-28 19:17:05 -06:00
|
|
|
|
pub fn do_pong(-c: pong) -> ping {
|
|
|
|
|
let (sp, rp) = ::pipes::entangle();
|
2013-02-15 04:44:18 -06:00
|
|
|
|
::pipes::send(c, pingpong::pong(sp));
|
|
|
|
|
rp
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
2012-06-25 14:21:01 -05:00
|
|
|
|
}
|
|
|
|
|
|
2012-06-26 00:11:19 -05:00
|
|
|
|
fn client(-chan: pingpong::client::ping) {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let chan = pingpong::client::do_ping(chan);
|
2012-07-14 00:57:48 -05:00
|
|
|
|
log(error, ~"Sent ping");
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let (_chan, _data) = pingpong::client::do_pong(chan);
|
2012-07-14 00:57:48 -05:00
|
|
|
|
log(error, ~"Received pong");
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn server(-chan: pingpong::server::ping) {
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let (chan, _data) = pingpong::server::do_ping(chan);
|
2012-07-14 00:57:48 -05:00
|
|
|
|
log(error, ~"Received ping");
|
2013-02-15 04:44:18 -06:00
|
|
|
|
let _chan = pingpong::server::do_pong(chan);
|
2012-07-14 00:57:48 -05:00
|
|
|
|
log(error, ~"Sent pong");
|
2012-06-26 00:11:19 -05:00
|
|
|
|
}
|
2012-06-25 14:21:01 -05:00
|
|
|
|
|
2013-02-01 21:43:17 -06:00
|
|
|
|
pub fn main() {
|
2012-06-26 00:11:19 -05:00
|
|
|
|
/*
|
|
|
|
|
// Commented out because of option::get error
|
|
|
|
|
|
|
|
|
|
let (client_, server_) = pingpong::init();
|
2013-02-25 17:16:36 -06:00
|
|
|
|
let client_ = ~mut Some(client_);
|
|
|
|
|
let server_ = ~mut Some(server_);
|
2012-06-26 00:11:19 -05:00
|
|
|
|
|
2013-02-15 04:44:18 -06:00
|
|
|
|
task::spawn {|client_|
|
2013-02-25 17:16:36 -06:00
|
|
|
|
let mut client__ = none;
|
|
|
|
|
*client_ <-> client__;
|
|
|
|
|
client(option::unwrap(client__));
|
2012-06-26 00:11:19 -05:00
|
|
|
|
};
|
2013-02-15 04:44:18 -06:00
|
|
|
|
task::spawn {|server_|
|
2013-02-25 17:16:36 -06:00
|
|
|
|
let mut server_ˊ = none;
|
|
|
|
|
*server_ <-> server_ˊ;
|
|
|
|
|
server(option::unwrap(server_ˊ));
|
2012-06-26 00:11:19 -05:00
|
|
|
|
};
|
|
|
|
|
*/
|
2012-06-25 14:21:01 -05:00
|
|
|
|
}
|