diff --git a/protocol/czar/engine.go b/protocol/czar/engine.go
index 4d80408..190030b 100644
--- a/protocol/czar/engine.go
+++ b/protocol/czar/engine.go
@@ -49,9 +49,9 @@ type Server struct {
 }
 
 // Serve incoming connections. Parameter cli will be closed automatically when the function exits.
-func (s *Server) Serve(ctx *daze.Context, cli io.ReadWriteCloser) error {
+func (s *Server) Serve(ctx *daze.Context, con io.ReadWriteCloser) error {
 	spy := &ashe.Server{Cipher: s.Cipher}
-	return spy.Serve(ctx, cli)
+	return spy.Serve(ctx, con)
 }
 
 // Close listener.
@@ -74,23 +74,23 @@ func (s *Server) Run() error {
 	go func() {
 		idx := uint32(math.MaxUint32)
 		for {
-			cli, err := l.Accept()
+			con, err := l.Accept()
 			if err != nil {
 				if !errors.Is(err, net.ErrClosed) {
 					log.Println("main:", err)
 				}
 				break
 			}
-			mux := NewMuxServer(cli)
+			mux := NewMuxServer(con)
 			go func() {
 				defer mux.Close()
-				for cli := range mux.Accept() {
+				for stm := range mux.Accept() {
 					idx++
 					ctx := &daze.Context{Cid: idx}
-					log.Printf("conn: %08x accept remote=%s", ctx.Cid, mux.con.RemoteAddr())
+					log.Printf("conn: %08x accept remote=%s", ctx.Cid, con.RemoteAddr())
 					go func() {
-						defer cli.Close()
-						if err := s.Serve(ctx, cli); err != nil {
+						defer stm.Close()
+						if err := s.Serve(ctx, stm); err != nil {
 							log.Printf("conn: %08x  error %s", ctx.Cid, err)
 						}
 						log.Printf("conn: %08x closed", ctx.Cid)
@@ -129,17 +129,17 @@ func (c *Client) Close() error {
 func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.ReadWriteCloser, error) {
 	select {
 	case mux := <-c.Mux:
-		srv, err := mux.Open()
+		stm, err := mux.Open()
 		if err != nil {
 			return nil, err
 		}
-		log.Printf("czar: mux slot stream id=0x%02x", srv.idx)
+		log.Printf("czar: mux slot stream id=0x%02x", stm.idx)
 		spy := &ashe.Client{Cipher: c.Cipher}
-		con, err := spy.Estab(ctx, srv, network, address)
+		srv, err := spy.Estab(ctx, stm, network, address)
 		if err != nil {
-			srv.Close()
+			stm.Close()
 		}
-		return con, err
+		return srv, err
 	case <-time.After(daze.Conf.DialerTimeout):
 		return nil, fmt.Errorf("dial tcp: %s: i/o timeout", address)
 	}
@@ -148,18 +148,18 @@ func (c *Client) Dial(ctx *daze.Context, network string, address string) (io.Rea
 // Run creates an establish connection to czar server.
 func (c *Client) Run() {
 	var (
+		con net.Conn
 		err error
 		mux *Mux
 		rtt = 0
 		sid = 0
-		srv net.Conn
 	)
 	for {
 		switch sid {
 		case 0:
-			srv, err = daze.Dial("tcp", c.Server)
+			con, err = daze.Dial("tcp", c.Server)
 			switch {
-			case srv == nil:
+			case con == nil:
 				log.Println("czar:", err)
 				select {
 				case <-time.After(time.Second * time.Duration(math.Pow(2, float64(rtt)))):
@@ -170,7 +170,7 @@ func (c *Client) Run() {
 				}
 			case err == nil:
 				log.Println("czar: mux init")
-				mux = NewMuxClient(srv)
+				mux = NewMuxClient(con)
 				rtt = 0
 				sid = 1
 			}