**** New globals: {i1:i1, i2:i2, i4:i4, i8:i8, r4:r4, r8:r8, s:s, u1:u1, u2:u2, u4:u4, u8:u8}
**** New definitions: N, type: s

> "hello"   has N
"hello" has N : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> "hello"  !has N
"hello" !has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello"  ~has N
"hello" ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> "hello" !~has N
"hello" !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello" ~!has N
"hello" !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello" not has N
"hello" not has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello" ~not has N
"hello" not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello" not ~has N
"hello" not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello" not~has N
"hello" not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> "hello"   has Wrap("")
"hello" has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello"  !has Wrap("")
"hello" !has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"  ~has Wrap("")
"hello" ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" !~has Wrap("")
"hello" !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" ~!has Wrap("")
"hello" !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not has Wrap("")
"hello" not has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" ~not has Wrap("")
"hello" not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not ~has Wrap("")
"hello" not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not~has Wrap("")
"hello" not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"   has Wrap("el")
"hello" has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello"  !has Wrap("el")
"hello" !has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"  ~has Wrap("el")
"hello" ~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" !~has Wrap("el")
"hello" !~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" ~!has Wrap("el")
"hello" !~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not has Wrap("el")
"hello" not has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" ~not has Wrap("el")
"hello" not ~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not ~has Wrap("el")
"hello" not ~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not~has Wrap("el")
"hello" not ~has Wrap("el") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(el)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"   has Wrap("eL")
"hello" has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"  !has Wrap("eL")
"hello" !has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello"  ~has Wrap("eL")
"hello" ~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" !~has Wrap("eL")
"hello" !~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" ~!has Wrap("eL")
"hello" !~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not has Wrap("eL")
"hello" not has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" ~not has Wrap("eL")
"hello" not ~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not ~has Wrap("eL")
"hello" not ~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" not~has Wrap("eL")
"hello" not ~has Wrap("eL") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(eL)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"   has Wrap("ex")
"hello" has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello"  !has Wrap("ex")
"hello" !has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello"  ~has Wrap("ex")
"hello" ~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: false
###
> "hello" !~has Wrap("ex")
"hello" !~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" ~!has Wrap("ex")
"hello" !~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" not has Wrap("ex")
"hello" not has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" ~not has Wrap("ex")
"hello" not ~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" not ~has Wrap("ex")
"hello" not ~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> "hello" not~has Wrap("ex")
"hello" not ~has Wrap("ex") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Call(∂.Test.Wrap(str(ex)):s)))
Func sig: () to b
Type: bool, Value: true 
###
> N   has N
N has N : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N  !has N
N !has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N  ~has N
N ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N !~has N
N !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N ~!has N
N !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not has N
N not has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N ~not has N
N not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not ~has N
N not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not~has N
N not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N   has Wrap("")
N has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N  !has Wrap("")
N !has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N  ~has Wrap("")
N ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N !~has Wrap("")
N !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N ~!has Wrap("")
N !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not has  Wrap("")
N not has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N ~not has  Wrap("")
N not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not ~has  Wrap("")
N not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N not~has  Wrap("")
N not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), Call(∂.Test.Wrap(str()):s)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N   has "el"
N has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N  !has "el"
N !has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N  ~has "el"
N ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> N !~has "el"
N !~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N ~!has "el"
N !~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N not has "el"
N not has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N ~not has "el"
N not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N not ~has "el"
N not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> N not~has "el"
N not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Global(N), str(el)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> "hello"   has s
"hello" has s : b
BndKind:BinaryOp, Type:b, Bnd:(Has(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: true 
###
> "hello"  !has s
"hello" !has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello"  ~has s
"hello" ~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: true 
###
> "hello" !~has s
"hello" !~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello" ~!has s
"hello" !~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello" not has s
"hello" not has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello" ~not has s
"hello" not ~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello" not ~has s
"hello" not ~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> "hello" not~has s
"hello" not ~has s : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(str(hello), Global(s)))
Func sig: (s:s) to b
Type: bool, Value: false
###
> Wrap("")   has Wrap("")
Wrap("") has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("")  !has Wrap("")
Wrap("") !has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("")  ~has Wrap("")
Wrap("") ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") !~has Wrap("")
Wrap("") !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") ~!has Wrap("")
Wrap("") !~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") not has  Wrap("")
Wrap("") not has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") ~not has  Wrap("")
Wrap("") not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") not ~has  Wrap("")
Wrap("") not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") not~has  Wrap("")
Wrap("") not ~has Wrap("") : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Call(∂.Test.Wrap(str()):s)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("")   has N
Wrap("") has N : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> Wrap("")  !has N
Wrap("") !has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("")  ~has N
Wrap("") ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: true 
###
> Wrap("") !~has N
Wrap("") !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("") ~!has N
Wrap("") !~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("") not has N
Wrap("") not has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("") ~not has N
Wrap("") not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("") not ~has N
Wrap("") not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("") not~has N
Wrap("") not ~has N : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), Global(N)))
Func sig: (N:s) to b
Type: bool, Value: false
###
> Wrap("")   has "el"
Wrap("") has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(Has(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("")  !has "el"
Wrap("") !has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("")  ~has "el"
Wrap("") ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCi(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: false
###
> Wrap("") !~has "el"
Wrap("") !~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") ~!has "el"
Wrap("") !~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") not has "el"
Wrap("") not has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") ~not has "el"
Wrap("") not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") not ~has "el"
Wrap("") not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> Wrap("") not~has "el"
Wrap("") not ~has "el" : b
BndKind:BinaryOp, Type:b, Bnd:(HasCiNot(Call(∂.Test.Wrap(str()):s), str(el)))
Func sig: () to b
Type: bool, Value: true 
###
> "Hello"   has ["h", "o", "O", "l", "w"]
"Hello" has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, Has(str(Hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
 2) false
 3) true 
 4) false
###
> "Hello"  !has ["h", "o", "O", "l", "w"]
"Hello" !has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasNot(str(Hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) false
 2) true 
 3) false
 4) true 
###
> "Hello"  ~has ["h", "o", "O", "l", "w"]
"Hello" ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCi(str(Hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) true 
 2) true 
 3) true 
 4) false
###
> "Hello" !~has ["h", "o", "O", "l", "w"]
"Hello" !~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCiNot(str(Hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) false
 3) false
 4) true 
###
> "hello" ~!has ["h", "o", "O", "l", "w"]
"hello" !~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCiNot(str(hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) false
 3) false
 4) true 
###
> "hello" not has ["h", "o", "O", "l", "w"]
"hello" not has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasNot(str(hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) true 
 3) false
 4) true 
###
> "hello" ~not has ["h", "o", "O", "l", "w"]
"hello" not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCiNot(str(hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) false
 3) false
 4) true 
###
> "hello" not ~has ["h", "o", "O", "l", "w"]
"hello" not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCiNot(str(hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) false
 3) false
 4) true 
###
> "hello" not~has ["h", "o", "O", "l", "w"]
"hello" not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(h), str(o), str(O), str(l), str(w)]:s*, HasCiNot(str(hello), Scope(1))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
 2) false
 3) false
 4) true 
###
> ["Hello", "World"]   has "H"
["Hello", "World"] has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, Has(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) false
###
> ["Hello", "World"]  !has "H"
["Hello", "World"] !has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"]  ~has "H"
["Hello", "World"] ~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCi(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) false
###
> ["Hello", "World"] !~has "H"
["Hello", "World"] !~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCiNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"] ~!has "H"
["Hello", "World"] !~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCiNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"] not has "H"
["Hello", "World"] not has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"] ~not has "H"
["Hello", "World"] not ~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCiNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"] not ~has "H"
["Hello", "World"] not ~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCiNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"] not~has "H"
["Hello", "World"] not ~has "H" : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, HasCiNot(Scope(1), str(H))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"]   has ["h", "o", "O", "l", "w"]
["Hello", "World"] has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, Has(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) true 
###
> ["Hello", "World"]  !has ["h", "o", "O", "l", "w"]
["Hello", "World"] !has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) false
###
> ["Hello", "World"]  ~has ["h", "o", "O", "l", "w"]
["Hello", "World"] ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCi(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) true 
###
> ["Hello", "World"] !~has ["h", "o", "O", "l", "w"]
["Hello", "World"] !~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCiNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
###
> ["Hello", "World"] ~!has ["h", "o", "O", "l", "w"]
["Hello", "World"] !~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCiNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
###
> ["Hello", "World"] not has ["h", "o", "O", "l", "w"]
["Hello", "World"] not has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) true 
 1) false
###
> ["Hello", "World"] ~not has ["h", "o", "O", "l", "w"]
["Hello", "World"] not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCiNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
###
> ["Hello", "World"] not ~has ["h", "o", "O", "l", "w"]
["Hello", "World"] not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCiNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
###
> ["Hello", "World"] not~has ["h", "o", "O", "l", "w"]
["Hello", "World"] not ~has ["h", "o", "O", "l", "w"] : b*
BndKind:Call, Type:b*, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [str(h), str(o)]:s*, HasCiNot(Scope(1), Scope(2))):b*))
Func sig: () to b*
Sequence: Seq<bool>
 0) false
 1) false
###
> ["Hello", "World"]   has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), Has(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) true 
     2) false
     3) true 
     4) false
 1) Sequence: Seq<bool>
     0) false
     1) true 
     2) false
     3) true 
     4) false
###
> ["Hello", "World"]  !has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] !has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) true 
     1) false
     2) true 
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) true 
     3) false
     4) true 
###
> ["Hello", "World"]  ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCi(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) true 
     1) true 
     2) true 
     3) true 
     4) false
 1) Sequence: Seq<bool>
     0) false
     1) true 
     2) true 
     3) true 
     4) true 
###
> ["Hello", "World"] !~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] !~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCiNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) false
     2) false
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) false
     3) false
     4) false
###
> ["Hello", "World"] ~!has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] !~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCiNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) false
     2) false
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) false
     3) false
     4) false
###
> ["Hello", "World"] not has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] not has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) true 
     1) false
     2) true 
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) true 
     3) false
     4) true 
###
> ["Hello", "World"] ~not has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] not ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCiNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) false
     2) false
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) false
     3) false
     4) false
###
> ["Hello", "World"] not ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] not ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCiNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) false
     2) false
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) false
     3) false
     4) false
###
> ["Hello", "World"] not~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]]
["Hello", "World"] not ~has [["h", "o", "O", "l", "w"], ["h", "o", "O", "l", "w"]] : b**
BndKind:Call, Type:b**, Bnd:(Call(∂.ForEach([map:1] [str(Hello), str(World)]:s*, [map:2] [[str(h), str(o), str(O), str(l), str(w)]:s*, [str(h), str(o), str(O), str(l), str(w)]:s*]:s**, Call(∂.ForEach([map:3] Scope(2), HasCiNot(Scope(1), Scope(3))):b*)):b**))
Func sig: () to b**
Sequence: Seq<Seq<bool>>
 0) Sequence: Seq<bool>
     0) false
     1) false
     2) false
     3) false
     4) true 
 1) Sequence: Seq<bool>
     0) true 
     1) false
     2) false
     3) false
     4) false
###
