diff --git a/_demo/cshademo/sha.go b/_demo/cshademo/sha.go
new file mode 100644
index 00000000..ad58d8f8
--- /dev/null
+++ b/_demo/cshademo/sha.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/goplus/llgo/c/openssl"
+)
+
+func main() {
+
+	var sha1 openssl.SHA_CTX
+	sha1.Init()
+	sha1.UpdateString("His money is twice tainted:")
+	sha1.UpdateString(" 'taint yours and 'taint mine.")
+
+	h := make([]byte, openssl.SHA_DIGEST_LENGTH)
+	sha1.Final(unsafe.SliceData(h))
+	fmt.Printf("%x\n", h)
+
+	var sha256 openssl.SHA256_CTX
+	sha256.Init()
+	sha256.UpdateString("His money is twice tainted:")
+	sha256.UpdateString(" 'taint yours and 'taint mine.")
+
+	hh := make([]byte, openssl.SHA256_DIGEST_LENGTH)
+	sha256.Final(unsafe.SliceData(hh))
+	fmt.Printf("%x\n", hh)
+}
diff --git a/c/openssl/sha.go b/c/openssl/sha.go
new file mode 100644
index 00000000..3cf7d891
--- /dev/null
+++ b/c/openssl/sha.go
@@ -0,0 +1,31 @@
+package openssl
+
+import "github.com/goplus/llgo/c"
+
+const (
+	SHA_DIGEST_LENGTH = 20
+	SHA_LBLOCK        = 16
+	SHA_CBLOCK        = (SHA_LBLOCK * 4)
+	SHA_LAST_BLOCK    = (SHA_CBLOCK - 8)
+
+	SHA256_CBLOCK            = (SHA_LBLOCK * 4)
+	SHA256_192_DIGEST_LENGTH = 24
+	SHA224_DIGEST_LENGTH     = 28
+	SHA256_DIGEST_LENGTH     = 32
+	SHA384_DIGEST_LENGTH     = 48
+	SHA512_DIGEST_LENGTH     = 64
+	SHA512_CBLOCK            = (SHA_LBLOCK * 8)
+)
+
+/*
+#  if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
+#   define SHA_LONG64 unsigned __int64
+#  elif defined(__arch64__)
+#   define SHA_LONG64 unsigned long
+#  else
+#   define SHA_LONG64 unsigned long long
+#  endif
+*/
+type SHA_LONG64 = c.UlongLong
+
+type SHA_LONG = c.Uint
diff --git a/c/openssl/sha1.go b/c/openssl/sha1.go
new file mode 100644
index 00000000..6ca7f6b2
--- /dev/null
+++ b/c/openssl/sha1.go
@@ -0,0 +1,63 @@
+package openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA_CTX struct {
+	H0, H1, H2, H3, H4 SHA_LONG
+	Nl, Nh             SHA_LONG
+	Data               [SHA_LBLOCK]SHA_LONG
+	Num                c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Init(SHA_CTX *c);
+//
+// llgo:link (*SHA_CTX).Init C.SHA1_Init
+func (c *SHA_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA_CTX).Update C.SHA1_Update
+func (c *SHA_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA1_Final(unsigned char *md, SHA_CTX *c);
+//
+//go:linkname sha1Final C.SHA1_Final
+func sha1Final(md *byte, c *SHA_CTX) c.Int
+
+func (c *SHA_CTX) Final(md *byte) c.Int {
+	return sha1Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
+//
+//go:linkname sha1Transform C.SHA1_Transform
+func sha1Transform(c *SHA_CTX, data *byte)
+
+func (c *SHA_CTX) Transform(data *byte) {
+	sha1Transform(c, data)
+}
+
+// unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA1 C.SHA1
+func SHA1(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA1Bytes(data []byte, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA1String(data string, md *byte) *byte {
+	return SHA1(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
diff --git a/c/openssl/sha256.go b/c/openssl/sha256.go
new file mode 100644
index 00000000..d18e3a2d
--- /dev/null
+++ b/c/openssl/sha256.go
@@ -0,0 +1,103 @@
+package openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA256_CTX struct {
+	H          [8]SHA_LONG
+	Nl, Nh     SHA_LONG
+	Data       [SHA_LBLOCK]SHA_LONG
+	Num, MdLen c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA256_CTX).Init224 C.SHA224_Init
+func (c *SHA256_CTX) Init224() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA256_CTX).Update224 C.SHA224_Update
+func (c *SHA256_CTX) Update224(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA256_CTX) Update224Bytes(data []byte) c.Int {
+	return c.Update224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA256_CTX) Update224String(data string) c.Int {
+	return c.Update224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha224Final C.SHA224_Final
+func sha224Final(md *byte, c *SHA256_CTX) c.Int
+
+func (c *SHA256_CTX) Final224(md *byte) c.Int {
+	return sha224Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Init(SHA256_CTX *c);
+//
+// llgo:link (*SHA256_CTX).Init C.SHA256_Init
+func (c *SHA256_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA256_CTX).Update C.SHA256_Update
+func (c *SHA256_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA256_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA256_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
+//
+//go:linkname sha256Final C.SHA256_Final
+func sha256Final(md *byte, c *SHA256_CTX) c.Int
+
+func (c *SHA256_CTX) Final(md *byte) c.Int {
+	return sha256Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
+//
+//go:linkname sha256Transform C.SHA256_Transform
+func sha256Transform(c *SHA256_CTX, data *byte)
+
+func (c *SHA256_CTX) Transform(data *byte) {
+	sha256Transform(c, data)
+}
+
+// unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA224 C.SHA224
+func SHA224(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA224Bytes(data []byte, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA224String(data string, md *byte) *byte {
+	return SHA224(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA256 C.SHA256
+func SHA256(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA256Bytes(data []byte, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA256String(data string, md *byte) *byte {
+	return SHA256(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
diff --git a/c/openssl/sha512.go b/c/openssl/sha512.go
new file mode 100644
index 00000000..6add73b7
--- /dev/null
+++ b/c/openssl/sha512.go
@@ -0,0 +1,101 @@
+package openssl
+
+import (
+	"unsafe"
+
+	"github.com/goplus/llgo/c"
+)
+
+type SHA512_CTX struct {
+	H          [8]SHA_LONG64
+	N1, Nh     SHA_LONG64
+	D          [SHA_LBLOCK]SHA_LONG64
+	Num, MdLen c.Uint
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA512_CTX).Init384 C.SHA384_Init
+func (c *SHA512_CTX) Init384() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA512_CTX).Update384 C.SHA384_Update
+func (c *SHA512_CTX) Update384(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+
+func (c *SHA512_CTX) Update384Bytes(data []byte) c.Int {
+	return c.Update384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+
+func (c *SHA512_CTX) Update384String(data string) c.Int {
+	return c.Update384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha384Final C.SHA384_Final
+func sha384Final(md *byte, c *SHA512_CTX) c.Int
+
+func (c *SHA512_CTX) Final384(md *byte) c.Int {
+	return sha384Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Init(SHA512_CTX *c);
+//
+// llgo:link (*SHA512_CTX).Init C.SHA512_Init
+func (c *SHA512_CTX) Init() c.Int { return 0 }
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
+//
+// llgo:link (*SHA512_CTX).Update C.SHA512_Update
+func (c *SHA512_CTX) Update(data unsafe.Pointer, n uintptr) c.Int { return 0 }
+func (c *SHA512_CTX) UpdateBytes(data []byte) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)))
+}
+func (c *SHA512_CTX) UpdateString(data string) c.Int {
+	return c.Update(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)))
+}
+
+// OSSL_DEPRECATEDIN_3_0 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
+//
+//go:linkname sha512Final C.SHA512_Final
+func sha512Final(md *byte, c *SHA512_CTX) c.Int
+
+func (c *SHA512_CTX) Final(md *byte) c.Int {
+	return sha512Final(md, c)
+}
+
+// OSSL_DEPRECATEDIN_3_0 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
+//
+//go:linkname sha512Transform C.SHA512_Transform
+func sha512Transform(c *SHA512_CTX, data *byte)
+
+func (c *SHA512_CTX) Transform(data *byte) {
+	sha512Transform(c, data)
+}
+
+// unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA384 C.SHA384
+func SHA384(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA384Bytes(data []byte, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA384String(data string, md *byte) *byte {
+	return SHA384(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
+
+// unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
+//
+//go:linkname SHA512 C.SHA512
+func SHA512(data unsafe.Pointer, n uintptr, md *byte) *byte
+
+func SHA512Bytes(data []byte, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.SliceData(data)), uintptr(len(data)), md)
+}
+
+func SHA512String(data string, md *byte) *byte {
+	return SHA512(unsafe.Pointer(unsafe.StringData(data)), uintptr(len(data)), md)
+}
diff --git a/ssa/expr.go b/ssa/expr.go
index 263ebb7a..f9adbd7d 100644
--- a/ssa/expr.go
+++ b/ssa/expr.go
@@ -1022,6 +1022,10 @@ func (b Builder) Do(da DoAction, fn Expr, args ...Expr) (ret Expr) {
 // Go spec (excluding "make" and "new").
 func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
 	switch fn {
+	case "max":
+		fallthrough
+	case "min":
+		return b.max(args...)
 	case "len":
 		if len(args) == 1 {
 			arg := args[0]
@@ -1128,6 +1132,12 @@ func (b Builder) BuiltinCall(fn string, args ...Expr) (ret Expr) {
 	panic("todo: " + fn)
 }
 
+// max return the max value for the args
+func (b Builder) max(args ...Expr) (ret Expr) {
+	//todo
+	return args[len(args)-1]
+}
+
 // Println prints the arguments to stderr, followed by a newline.
 func (b Builder) Println(args ...Expr) (ret Expr) {
 	return b.PrintEx(true, args...)