var tlsOpts: NWProtocolTLS.Options? = nil
        if (false) { // TOGGLE TLS HERE
            tlsOpts = NWProtocolTLS.Options()
            let secOpts = tlsOpts!.securityProtocolOptions
            
            let pskData = "mypsk".data(using: .utf8)!.withUnsafeBytes { DispatchData(bytes: $0) }
            let pskIdentityData = "myid".data(using: .utf8)!.withUnsafeBytes { DispatchData(bytes: $0) }
            sec_protocol_options_add_pre_shared_key(
                secOpts,
                pskData as __DispatchData,
                pskIdentityData as __DispatchData)
        }
        
        let listener = try! NWListener(
            using: NWParameters(tls: tlsOpts, tcp: .init()),
            on: .init(integerLiteral: 1234))
        
        listener.stateUpdateHandler = { state in
            switch state {
            case .ready:
                print("Listening")
                
                let clientConn = NWConnection(
                    host: .ipv4(.loopback),
                    port: 1234,
                    using: .init(tls: tlsOpts, tcp: .init()))
                
                clientConn.start(queue: DispatchQueue.main)
                
                clientConn.send(
                    content: "Hello, Server!".data(using: .utf8), // 14 nytes
                    contentContext: .defaultMessage,
                    isComplete: true,
                    completion: .contentProcessed({ (error) in
                        print("Client's send 1 completed (error \(String(describing: error)))")
                        
                        DispatchQueue.main.asyncAfter(wallDeadline: .now() + 5) {
                            clientConn.send(
                                content: "End.".data(using: .utf8), // 4 bytes
                                contentContext: .finalMessage,
                                completion: .contentProcessed({ (error) in
                                    print("Client's send 2 completed (error \(String(describing: error)))")
                                }))

                            DispatchQueue.main.asyncAfter(wallDeadline: .now() + 5) {
                                clientConn.cancel()
                            }
                        }
                    }))
                
            default:
                break
            }
        }
        
        listener.newConnectionHandler = { conn in
            print("Listener received connection")
            
            func receiveMore() {
                conn.receive(
                    minimumIncompleteLength: 0,
                    maximumLength: Int.max
                ) { (data, ctx, isComplete, error) in
                    print("Server received data = \(String(describing: data)), ctx.isFinal = \(String(describing: ctx?.isFinal)), isComplete = \(isComplete), error = \(String(describing: error))")
                    
                    if !isComplete {
                        receiveMore()
                    }
                }
            }
            conn.start(queue: DispatchQueue.main)
            
            receiveMore()
        }
        
        listener.start(queue: DispatchQueue.main)
    }