java复制代码pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));

java复制代码private void initialize(ChannelHandlerContext ctx) {
    // Avoid the case where destroy() is called before scheduling timeouts.
    // See: https://github.com/netty/netty/issues/143
    switch (state) {
    case 1:
    case 2:
        return;
    default:
         break;
    }

    state = 1;
    initOutputChanged(ctx);

    lastReadTime = lastWriteTime = ticksInNanos();
    if (readerIdleTimeNanos > 0) {
        readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                readerIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
    if (writerIdleTimeNanos > 0) {
        writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
                writerIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
    if (allIdleTimeNanos > 0) {
        allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
                allIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
}

java复制代码public class HeartBeatServer {

    public static void main(String[] args) throws Exception {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(boss, worker)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            //IdleStateHandler的readerIdleTime参数指定超过3秒还没收到客户端的连接，
                            //会触发IdleStateEvent事件并且交给下一个handler处理，下一个handler必须
                            //实现userEventTriggered方法处理对应事件
                            pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
                            pipeline.addLast(new HeartBeatServerHandler());
                        }
                    });
            System.out.println("netty server start。。");
            ChannelFuture future = bootstrap.bind(9000).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            worker.shutdownGracefully();
            boss.shutdownGracefully();
        }
    }
}

java复制代码public class HeartBeatClient {
    public static void main(String[] args) throws Exception {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new HeartBeatClientHandler());
                        }
                    });

            System.out.println("netty client start。。");
            Channel channel = bootstrap.connect("127.0.0.1", 9000).sync().channel();
            String text = "Heartbeat Packet";
            Random random = new Random();
            while (channel.isActive()) {
                int num = random.nextInt(10);
                Thread.sleep(2 * 1000);
                channel.writeAndFlush(text);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }

    static class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {

        @Override
        protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
            System.out.println(" client received :" + msg);
            if (msg != null && msg.equals("idle close")) {
                System.out.println(" 服务端关闭连接，客户端也关闭");
                ctx.channel().closeFuture();
            }
        }
    }
}

java复制代码public class HeartBeatServerHandler extends SimpleChannelInboundHandler<String> {

    int readIdleTimes = 0;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
        System.out.println(" ====== > [server] message received : " + s);
        if ("Heartbeat Packet".equals(s)) {
            ctx.channel().writeAndFlush("ok");
        } else {
            System.out.println(" 其他信息处理 ... ");
        }
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        IdleStateEvent event = (IdleStateEvent) evt;

        String eventType = null;
        switch (event.state()) {
            case READER_IDLE:
                eventType = "读空闲";
                readIdleTimes++; // 读空闲的计数加1
                break;
            case WRITER_IDLE:
                eventType = "写空闲";
                // 不处理
                break;
            case ALL_IDLE:
                eventType = "读写空闲";
                // 不处理
                break;
        }



        System.out.println(ctx.channel().remoteAddress() + "超时事件：" + eventType);
        if (readIdleTimes > 3) {
            System.out.println(" [server]读空闲超过3次，关闭连接，释放更多资源");
            ctx.channel().writeAndFlush("idle close");
            ctx.channel().close();
        }
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.err.println("=== " + ctx.channel().remoteAddress() + " is active ===");
    }

ini复制代码输入：nums = [1,12,-5,-6,50,3], k = 4
输出：12.75
解释：最大平均数 (12-5-6+50)/4 = 51/4 = 12.75

ini复制代码输入： nums = [5], k = 1
输出： 5.00000

Kotlin复制代码class Solution {
    fun findMaxAverage(nums: IntArray, k: Int): Double {
        var sum = 0
        for(i in 0 until k) {
            sum += nums[i]
        }
        var maxSum = sum
        for(i in k until nums.size) {
            sum = sum - nums[i-k] + nums[i]
            maxSum = Math.max(maxSum,sum)
        }
        return maxSum.toDouble() / k
    }
}

java复制代码/**
 * @author: 微信公众号【老周聊架构】
 */
public class KafkaConsumerTest {
    public static void main(String[] args) {
        Properties props = new Properties();

        // kafka地址,列表格式为host1:port1,host2:port2,...，无需添加所有的集群地址，kafka会根据提供的地址发现其他的地址(建议多提供几个，以防提供的服务器关闭) 必须设置
        props.put("bootstrap.servers", "localhost:9092");
        // key序列化方式 必须设置
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value序列化方式 必须设置
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("group.id", "consumer_riemann_test");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        // 可消费多个topic,组成一个list
        String topic = "riemann_kafka_test";
        consumer.subscribe(Arrays.asList(topic));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s \n", record.offset(), record.key(), record.value());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

java复制代码long trySend(long now) {
    long pollDelayMs = maxPollTimeoutMs;

    // send any requests that can be sent now
    // 遍历 unsent 集合
    for (Node node : unsent.nodes()) {
        Iterator<ClientRequest> iterator = unsent.requestIterator(node);
        if (iterator.hasNext())
            pollDelayMs = Math.min(pollDelayMs, client.pollDelayMs(node, now));

        while (iterator.hasNext()) {
            ClientRequest request = iterator.next();
            // 调用 NetworkClient.ready(）检查是否可以发送请求
            if (client.ready(node, now)) {
                // 调用 NetworkClient.send(）方法，等待发送请求。
                client.send(request, now);
                // 从 unsent 集合中删除此请求
                iterator.remove();
            } else {
                // try next node when current node is not ready
                break;
            }
        }
    }
    return pollDelayMs;
}

java复制代码private void checkDisconnects(long now) {
    // any disconnects affecting requests that have already been transmitted will be handled
    // by NetworkClient, so we just need to check whether connections for any of the unsent
    // requests have been disconnected; if they have, then we complete the corresponding future
    // and set the disconnect flag in the ClientResponse
    for (Node node : unsent.nodes()) {
        // 检测消费者与每个 Node 之间的连接状态
        if (client.connectionFailed(node)) {
            // Remove entry before invoking request callback to avoid callbacks handling
            // coordinator failures traversing the unsent list again.
            // 在调用请求回调之前删除条目以避免回调处理再次遍历未发送列表的协调器故障。
            Collection<ClientRequest> requests = unsent.remove(node);
            for (ClientRequest request : requests) {
                RequestFutureCompletionHandler handler = (RequestFutureCompletionHandler) request.callback();
                AuthenticationException authenticationException = client.authenticationException(node);
                // 调用 ClientRequest 的回调函数
                handler.onComplete(new ClientResponse(request.makeHeader(request.requestBuilder().latestAllowedVersion()),
                        request.callback(), request.destination(), request.createdTimeMs(), now, true,
                        null, authenticationException, null));
            }
        }
    }
}

java复制代码public void maybeTriggerWakeup() {
    // 通过 wakeupDisabled 检测是否在执行不可中断的方法，通过 wakeup 检测是否有中断请求。
    if (!wakeupDisabled.get() && wakeup.get()) {
        log.debug("Raising WakeupException in response to user wakeup");
        // 重置中断标志
        wakeup.set(false);
        throw new WakeupException();
    }
}

java复制代码private void failExpiredRequests(long now) {
    // clear all expired unsent requests and fail their corresponding futures
    // 清除所有过期的未发送请求并使其相应的 futures 失败
    Collection<ClientRequest> expiredRequests = unsent.removeExpiredRequests(now);
    for (ClientRequest request : expiredRequests) {
        RequestFutureCompletionHandler handler = (RequestFutureCompletionHandler) request.callback();
        // 调用回调函数
        handler.onFailure(new TimeoutException("Failed to send request after " + request.requestTimeoutMs() + " ms."));
    }
}

private Collection<ClientRequest> removeExpiredRequests(long now) {
    List<ClientRequest> expiredRequests = new ArrayList<>();
    for (ConcurrentLinkedQueue<ClientRequest> requests : unsent.values()) {
        Iterator<ClientRequest> requestIterator = requests.iterator();
        while (requestIterator.hasNext()) {
            ClientRequest request = requestIterator.next();
            // 检查是否超时
            long elapsedMs = Math.max(0, now - request.createdTimeMs());
            if (elapsedMs > request.requestTimeoutMs()) {
                // 将过期请求加入到 expiredRequests 集合
                expiredRequests.add(request);
                requestIterator.remove();
            } else
                break;
        }
    }
    return expiredRequests;
}

java复制代码public RequestFuture<ClientResponse> send(Node node,
                                          AbstractRequest.Builder<?> requestBuilder,
                                          int requestTimeoutMs) {
    long now = time.milliseconds();
    RequestFutureCompletionHandler completionHandler = new RequestFutureCompletionHandler();
    ClientRequest clientRequest = client.newClientRequest(node.idString(), requestBuilder, now, true,
            requestTimeoutMs, completionHandler);
    // 创建 clientRequest 对象，并保存到 unsent 集合中。
    unsent.put(node, clientRequest);

    // wakeup the client in case it is blocking in poll so that we can send the queued request
    // 唤醒客户端以防它在轮询中阻塞，以便我们可以发送排队的请求。
    client.wakeup();
    return completionHandler.future;
}

java复制代码/**
 * 适配器
 * Adapt from a request future of one type to another.
 *
 * @param <F> Type to adapt from
 * @param <T> Type to adapt to
 */
public abstract class RequestFutureAdapter<F, T> {
    public abstract void onSuccess(F value, RequestFuture<T> future);

    public void onFailure(RuntimeException e, RequestFuture<T> future) {
        future.raise(e);
    }
}

/**
 * RequestFuture<T> 适配成 RequestFuture<S>
 * Convert from a request future of one type to another type
 * @param adapter The adapter which does the conversion
 * @param <S> The type of the future adapted to
 * @return The new future
 */
public <S> RequestFuture<S> compose(final RequestFutureAdapter<T, S> adapter) {
    // 适配之后的结果
    final RequestFuture<S> adapted = new RequestFuture<>();
    // 在当前 RequestFuture 上添加监听器
    addListener(new RequestFutureListener<T>() {
        @Override
        public void onSuccess(T value) {
            adapter.onSuccess(value, adapted);
        }

        @Override
        public void onFailure(RuntimeException e) {
            adapter.onFailure(e, adapted);
        }
    });
    return adapted;
}

java复制代码public void chain(final RequestFuture<T> future) {
    // 添加监听器
    addListener(new RequestFutureListener<T>() {
        @Override
        public void onSuccess(T value) {
            // 通过监听器将 value 传递给下一个 RequestFuture 对象
            future.complete(value);
        }

        @Override
        public void onFailure(RuntimeException e) {
            // 通过监听器将异常传递给下一个 RequestFuture 对象
            future.raise(e);
        }
    });
}

java复制代码public class LengthComparator implements Comparator<String> {
    @Override
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
}

java复制代码String[] strArr = new String[]{"abcde", "qwer"};
Arrays.sort(strArr, new LengthComparator());

java复制代码Arrays.sort(strArr, (String a, String b) -> a.length() - b.length());

java复制代码// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

java复制代码// 用匿名内部类的方式来创建线程 
new Thread(new Runnable() { 
    @Override 
    public void run() { 
        System.out.println("hello world"); 
    } 
});


// 使用Lambda来创建线程
new Thread(() -> System.out.println("hello world"));

java复制代码@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used...
     */
    public abstract void run();
}

java复制代码@FunctionalInterface
public interface Comparator<T> {
    
    int compare(T o1, T o2);

    boolean equals(Object obj);

    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }

    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }
}

java复制代码Timer timer = new Timer(1000, event -> System.out.println("this time is " + new Date()));

java复制代码Timer timer = new Timer(1000, System.out::println);

java复制代码1. object::instanceMethod
2. Class::instanceMethod
3. Class::staticMethod

java复制代码ArrayList<String> names = ... ;
Stream<Persion> stream = names.stream().map(Person::new);
List<Person> people = stream.collect(Collectors.toList());

java复制代码public static void repeatMessage(String text, int delay){
    ActionListener listener = event -> 
        {
            System.out.printLn(text);
        };
    new Timer(delay, listener).start();
}

// 调用
repeatMessage("Hello", 1000);

js复制代码java -jar BootWxTool-0.0.1-SNAPSHOT.jar

js复制代码/www/server/nginx/conf

js复制代码include /www/server/panel/vhost/nginx/*.conf;

js复制代码cd /www/server/panel/vhost/nginx/

js复制代码mkdir wxtool.conf

js复制代码server
{
    listen 80;
    listen 443 ssl http2;
    server_name weixin.******.com;
    index index.php index.html index.htm default.php default.htm default.html;
    root /java/springboot;
    if ($server_port !~ 443){
        rewrite ^(/.*)$ https://$host$1 permanent;
    }
	
	location / {
    proxy_pass http://127.0.0.1:8080;
    proxy_set_header Host $host:80;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	}
    #HTTP_TO_HTTPS_END
    ssl_certificate    /etc/letsencrypt/live/weixin/6199589_weixin.ruankaoti.com.pem;
    ssl_certificate_key    /etc/letsencrypt/live/weixin/6199589_weixin.ruankaoti.com.key;
    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    error_page 497  https://$host$request_uri;

    #SSL-END
    
  
    error_page 404 /404.html;
    error_page 502 /502.html;
    #ERROR-PAGE-END
    
    
    #禁止访问的文件或目录
    location ~ ^/(\.user.ini|\.htaccess|\.git|\.svn|\.project|LICENSE|README.md)
    {
        return 404;
    }
 
    location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$
    {
        expires      30d;
        error_log off;
        access_log off;
    }
    
    location ~ .*\.(js|css)?$
    {
        expires      12h;
        error_log off;
        access_log off; 
    }
    access_log  /www/wwwlogs/weixin.*****.com.log;
    error_log  /www/wwwlogs/weixin.*****.com.error.log;
}

sql复制代码    update T set c=c+1 where ID=1 
    -- ID为索引

sql复制代码SELECT DISTINCT(s2.salary)
                    FROM salaries AS s2
                    ORDER BY s2.salary DESC
                    LIMIT 1, 1

sql复制代码SELECT emp_no, s1.salary
FROM salaries AS s1
WHERE s1.salary = (SELECT DISTINCT(s2.salary)
                    FROM salaries AS s2
                    ORDER BY s2.salary DESC
                    LIMIT 1, 1)

sql复制代码SELECT e.emp_no, salary, last_name, first_name
FROM employees AS e INNER JOIN salaries AS s
ON e.emp_no = s.emp_no
AND s.salary = (SELECT max(salary)
	             FROM salaries
	             WHERE salary < (SELECT MAX(salary)
	                            FROM salaries))

php复制代码class UserUniversalAction extends BaseUserAction
{
    //输入参数
    protected $_userid;      //当前用户ID
    protected $_actionId;    //动作ID
    protected $_extra = [];       //动作携带的额外参数
    protected $_otherUserid; //对方用户ID
    protected $_data = [];        //中间存储
    protected $_houseOpen = [];
    protected $_userConsume = null;
    protected $_now;

    //输出参数
    protected $_pass = true;            //财务性约束，有没有消费通过
    protected $_rechargeType = null;    //消费的类型
    protected $_propCount = 0;
    protected $_consumeSuccess = false; //消费成功-默认false
    protected $_canInvite = false;      //
    protected $_errorCode = 0;          //非财务行约束，动作的关系执行条件
    protected $_needAfterAction = true;
    //protected $_out = [];               //动作执行完成后，输出结果

    public $hasRight = false;
    
    public function __construct($userid, $otherUserid = '')
    {
        parent::__construct($userid, 0);
        $this->_otherUserid = $otherUserid;
        //初始化参数
        $this->_houseOpen = HouseOpen::getCurrentOpen();
        //消费初始化
        $this->_userConsume = new UserConsume($this->_userid);
        $this->_now = time();
    }

    //设置执行动作
    public function setAction($actionId, $extra = [])
    {
        //设置动作参数
        $this->_actionId = $actionId;
        $this->_extra = $extra;

        //前置动作，执行权限校验等
        $this->_beforeAction();
        //只有非财务性约束和财务性约束通过后，才能继续执行
        if ($this->_errorCode == 0 && $this->_pass) {
            //执行动作
            $this->_actionExecute();
            if ($this->_errorCode == 0) {
                //后置动作
                $this->_afterAction();
            }
        }
    }

    //获取动作执行结果
    public function getActionResult()
    {
        return [
            //财务性限制
            'pass' => $this->_pass,
            'rechargeType' => $this->_rechargeType,
            'propCount' => $this->_propCount,
            'canInvite' => $this->_canInvite,
            //业务性限制
            'errorCode' => $this->_errorCode,
            'out' => $this->_data
        ];
    }

php复制代码    //设置执行动作
    public function setAction($actionId, $extra = [])
    {
        //设置动作参数
        $this->_actionId = $actionId;
        $this->_extra = $extra;

        //前置动作，执行权限校验等
        $this->_beforeAction();
        //只有非财务性约束和财务性约束通过后，才能继续执行
        if ($this->_errorCode == 0 && $this->_pass) {
            //执行动作
            $this->_actionExecute();
            if ($this->_errorCode == 0) {
                //后置动作
                $this->_afterAction();
            }
        }
    }

php复制代码   protected function _actionExecute()
   {
        //执行权限校验
        switch ($this->_actionId) {
              .
              .
              .
            case self::TYPE_ACTION_END:
                $this->_doAppointmentEndActionExecute();
                break;
        }
    }
    
    protected function _afterAction()
    {
        //动作后置操作
        switch ($this->_actionId) {
            .
            .
            .
            case self::TYPE_ACTION_END:
                $this->_afterAppointmentFinish();
                break;
            default:
        }
    }
    
    protected function _doAppointmentEndActionExecute()
    {
        $appointmentModel = AppointmentInfo::query()->selectRaw('id,userid,"inviteeUserid",status,endtime,"callStartTimestamp","callDuration","isConsume","appointmentOpenId"')
            ->where('id', $this->_extra['appointmentId'])->first();
        .
        .
        .
        $appointmentModel->endtime = time();
        $appointmentModel->status = AppointmentInfo::TYPE_STATUS_END;
        $appointmentModel->save();
        $this->_data = $appointmentModel->toArray();
        .
        .
        .
    }
        
    protected function _afterAppointmentFinish()
    {
        $houseOpen = $this->_houseOpen; //减少1次DB查询
        if ($houseOpen['status'] != HouseOpen::HOUSE_STATUS_OPEN) {
            return false;
        }
        //减少2次DB查询
        if (isset($this->_data)
            && $this->_data['isConsume'] == AppointmentInfo::TYPE_IS_CONSUME
            && $this->_data['appointmentOpenId'] == $houseOpen['currentAppointmentOpenId']
            && $this->_data['callDuration'] < 60) { //约会时长不足1分钟，花了多少补偿多少精酿券
            .
            .
            .
            }
        }
    }

php复制代码    //输入参数
    protected $_userid;      //当前用户ID
    protected $_actionId;    //动作ID
    protected $_extra = [];       //动作携带的额外参数
    protected $_otherUserid; //对方用户ID
    protected $_data = [];        //中间存储
    protected $_houseOpen = [];
    protected $_userConsume = null;
    protected $_now;

xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

yaml复制代码spring:
  redis:
    host: 127.0.0.1
    database: 5
    password:
    port: 6379

java复制代码@Component
public class ReceiveListener implements MessageListener {

    @Override
    public void onMessage(Message message, byte[] bytes) {
        System.out.println("我是监听者小A,我监听到的消息是 " + message.toString());
    }

}

scala复制代码@Configuration
public class ReceiveListenerConfig extends CachingConfigurerSupport {

    /**
     * 消息监听容器
     *
     * @param factory
     * @return
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory factory){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(factory);
        //订阅一个通道 该处的通道名是发布消息时的名称
        container.addMessageListener(catAdapter(),new PatternTopic("topic"));
        return container;
    }

    /**
     * 消息监听适配器，绑定消息处理器
     *
     * @return
     */
    @Bean
    MessageListenerAdapter catAdapter(){
        return new MessageListenerAdapter(new ReceiveListener());
    }

}